自学教程：C++ GetNativeSystemInfo函数代码示例

JNIEXPORT void JNICALLJava_net_rubygrapefruit_platform_internal_jni_NativeLibraryFunctions_getSystemInfo(JNIEnv *env, jclass target, jobject info, jobject result) {    jclass infoClass = env->GetObjectClass(info);    OSVERSIONINFOEX versionInfo;    versionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);    if (GetVersionEx((OSVERSIONINFO*)&versionInfo) == 0) {        mark_failed_with_errno(env, "could not get version info", result);        return;    }    SYSTEM_INFO systemInfo;    GetNativeSystemInfo(&systemInfo);    jstring arch = NULL;    if (systemInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) {        arch = env->NewStringUTF("amd64");    } else if (systemInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL) {        arch = env->NewStringUTF("x86");    } else if (systemInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_IA64) {        arch = env->NewStringUTF("ia64");    } else {        arch = env->NewStringUTF("unknown");    }    jmethodID method = env->GetMethodID(infoClass, "windows", "(IIIZLjava/lang/String;)V");    env->CallVoidMethod(info, method, versionInfo.dwMajorVersion, versionInfo.dwMinorVersion,                        versionInfo.dwBuildNumber, versionInfo.wProductType == VER_NT_WORKSTATION,                        arch);}

QTCREATOR_UTILS_EXPORT bool winIs64BitSystem(){    SYSTEM_INFO systemInfo;    GetNativeSystemInfo(&systemInfo);    return systemInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64            || systemInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_IA64;}

/**@Status Caveat@Notes Only HW_AVAILCPU is supported*/extern "C" int sysctl(const int* name, u_int namelen, void* oldp, size_t* oldlenp, const void* newp, size_t newlen) {    if (namelen < 2 || name == nullptr) {        errno = EINVAL;        return -1;    }    if (namelen != 2 ||        name[0] != CTL_HW ||        name[1] != HW_AVAILCPU) {        UNIMPLEMENTED_WITH_MSG("sysctl only supports querying HW_AVAILCPU");        errno = EOPNOTSUPP;        return -1;    }    if (*oldlenp < sizeof(int)) {        *oldlenp = sizeof(int);        errno = ENOMEM;        return -1;    }    SYSTEM_INFO systemInfo;    GetNativeSystemInfo(&systemInfo);    *static_cast<int*>(oldp) = systemInfo.dwNumberOfProcessors;    *oldlenp = sizeof(int);    return 0;}

	NTSTATUS ProcessCore::Init() {		// Detect x86 OS		SYSTEM_INFO info = {{0}};		GetNativeSystemInfo(&info);		if(info.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL) {			_native.reset(new x86Native(_hProcess));		} else {			// Detect wow64 barrier			BOOL wowSrc = FALSE;			IsWow64Process(GetCurrentProcess(), &wowSrc);			if(wowSrc == TRUE)				_native.reset(new NativeWow64(_hProcess));			else				_native.reset(new Native(_hProcess));		}		// Get DEP info		// For native x64 processes DEP is always enabled		if(_native->GetWow64Barrier().targetWow64 == false) {			_dep = true;		} else {			DWORD flags = 0;			BOOL perm = 0;			if(SAFE_CALL(GetProcessDEPPolicy, _hProcess, &flags, &perm))				_dep = (flags & PROCESS_DEP_ENABLE) != 0;		}		return STATUS_SUCCESS;	}

int Engine::GetPrcessorInfo(){	SYSTEM_INFO stInfo;	//GetSystemInfo(&stInfo);	GetNativeSystemInfo(&stInfo);	switch (stInfo.wProcessorArchitecture)	{	case PROCESSOR_ARCHITECTURE_INTEL:		//printf("Processor Architecture: Intel x86/n");		return 0;		break;	case PROCESSOR_ARCHITECTURE_IA64:		//printf("Processor Type: Intel x64/n");		return 6;		break;	case PROCESSOR_ARCHITECTURE_AMD64:		//printf("Processor Type: AMD 64/n");		return 9;		break;	default:		//printf("Unknown processor architecture/n");		return -1;	}}

  virtual int load_driver_()  {      SYSTEM_INFO sys_info;      ZeroMemory(&sys_info, sizeof(sys_info));      GetCurrentDirectory(MAX_PATH - 10, driver_filename);      GetNativeSystemInfo(&sys_info);      switch(sys_info.wProcessorArchitecture)      {          case PROCESSOR_ARCHITECTURE_AMD64:            wcscat_s(driver_filename, MAX_PATH, L"//winpmem_64.sys");            if(GetFileAttributes(driver_filename) ==  INVALID_FILE_ATTRIBUTES)            {                std::cout << "ERROR: winpmem_64.sys not found in current directory. Download it from https://volatility.googlecode.com/svn-history/r2813/branches/scudette/tools/windows/winpmem/binaries/winpmem_64.sys ." << std::endl;                std::cout << "ERROR: Memory bandwidth statistics will not be available." << std::endl;            }            break;          case PROCESSOR_ARCHITECTURE_INTEL:            wcscat_s(driver_filename, MAX_PATH, L"//winpmem_32.sys");            if(GetFileAttributes(driver_filename) ==  INVALID_FILE_ATTRIBUTES)            {                std::cout << "ERROR: winpmem_32.sys not found in current directory. Download it from https://volatility.googlecode.com/svn-history/r2813/branches/scudette/tools/windows/winpmem/binaries/winpmem_32.sys ." << std::endl;                std::cout << "ERROR: Memory bandwidth statistics will not be available." << std::endl;            }            break;        default:            return -1;      }      return 1;  }

int main(int argc, char *argv[]){    uv_setup_args(argc, argv); // no-op on Windows#elsestatic void lock_low32() {#if defined(_P64) && defined(JL_DEBUG_BUILD)    // block usage of the 32-bit address space on win64, to catch pointer cast errors    char *const max32addr = (char*)0xffffffffL;    SYSTEM_INFO info;    MEMORY_BASIC_INFORMATION meminfo;    GetNativeSystemInfo(&info);    memset(&meminfo, 0, sizeof(meminfo));    meminfo.BaseAddress = info.lpMinimumApplicationAddress;    while ((char*)meminfo.BaseAddress < max32addr) {        VirtualQuery(meminfo.BaseAddress, &meminfo, sizeof(meminfo));        if (meminfo.State == MEM_FREE) { // reserve all free pages in the first 4GB of memory            char *first = (char*)meminfo.BaseAddress;            char *last = first + meminfo.RegionSize;            char *p;            if (last > max32addr)                last = max32addr;            // adjust first up to the first allocation granularity boundary            // adjust last down to the last allocation granularity boundary            first = (char*)(((long long)first + info.dwAllocationGranularity - 1) & ~(info.dwAllocationGranularity - 1));            last = (char*)((long long)last & ~(info.dwAllocationGranularity - 1));            if (last != first) {                p = VirtualAlloc(first, last - first, MEM_RESERVE, PAGE_NOACCESS); // reserve all memory in between                assert(p == first);            }        }        meminfo.BaseAddress += meminfo.RegionSize;    }#endif}

		WitchSystemInfo::ProcessorArchitecture WitchSystemInfo::architecture()		{			static WitchSystemInfo::ProcessorArchitecture arch;						if(arch)				return arch;				#if WITCHENGINE_PLATFORM == WITCHENGINE_PLATFORM_WIN32 || WITCHENGINE_PLATFORM == WITCHENGINE_PLATFORM_WIN64			SYSTEM_INFO sysinfo;						GetNativeSystemInfo(&sysinfo);			if(sysinfo.wProcessorArchitecture == 9)			{				arch = WitchSystemInfo::PA_AMD64;			}			else if(sysinfo.wProcessorArchitecture == 6)			{				arch = WitchSystemInfo::PA_IA64;			}			else if(sysinfo.wProcessorArchitecture == 0)			{				arch = WitchSystemInfo::PA_INTEL;			}			else			{				arch = WitchSystemInfo::PA_UNKNOWN;			}#endif			return arch;		}

CStdString CSysInfo::GetUAWindowsVersion(){  OSVERSIONINFOEX osvi = {};  osvi.dwOSVersionInfoSize = sizeof(osvi);  CStdString strVersion = "Windows NT";  if (GetVersionEx((OSVERSIONINFO *)&osvi))  {    strVersion += StringUtils::Format(" %d.%d", osvi.dwMajorVersion, osvi.dwMinorVersion);  }  SYSTEM_INFO si = {};  GetSystemInfo(&si);  BOOL bIsWow = FALSE;  if (IsWow64Process(GetCurrentProcess(), &bIsWow))  {    if (bIsWow)    {      strVersion.append(";WOW64");      GetNativeSystemInfo(&si);     // different function to read the info under Wow    }  }  if (si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_AMD64)    strVersion.append(";Win64;x64");  else if (si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_IA64)    strVersion.append(";Win64;IA64");  return strVersion;}

   /// <summary>Identify the windows version</summary>   WindowsVersion::WindowsVersion() : Version(OS::Future)   {      // Prepare      ZeroMemory((OSVERSIONINFO*)this, sizeof(OSVERSIONINFO));      dwOSVersionInfoSize = sizeof(OSVERSIONINFO);         // Query windows version      if (GetVersionEx(this))      {         switch (dwMajorVersion)         {         // [WINDOWS NT 5] Windows 2000 or Windows XP         case 5:              switch (dwMinorVersion)            {            case 0:  Version = OS::Win2000;     break;            case 1:  Version = OS::WinXP;       break;            case 2:  Version = OS::Server2003;  break;            }            break;         // [WINDOWS NT 6] Windows Vista, 7, or newer         case 6:            switch (dwMinorVersion)            {            case 0:  Version = OS::Vista;   break;            case 1:  Version = OS::Win7;    break;            default: Version = OS::Future;  break;            }            break;         }      }      // Set name      switch (Version)      {      case OS::Win2000:    Name = L"Windows 2000";         break;      case OS::WinXP:      Name = L"Windows XP";           break;      case OS::Server2003: Name = L"Windows Server 2003";  break;      case OS::Vista:      Name = L"Windows Vista";        break;      case OS::Win7:       Name = L"Windows 7";            break;      case OS::Future:     Name = L"Windows Future";       break;      }      // Set Full name      FullName = VString(L"%s %s (v%d.%d)", Name.c_str(), szCSDVersion, dwMajorVersion, dwMinorVersion);      // Query architecture      SYSTEM_INFO si;      GetNativeSystemInfo(&si);      switch (si.wProcessorArchitecture)      {      case PROCESSOR_ARCHITECTURE_AMD64:   Architecture = L"x64";      break;      case PROCESSOR_ARCHITECTURE_IA64:    Architecture = L"Itanium";  break;      case PROCESSOR_ARCHITECTURE_INTEL:   Architecture = L"x86";      break;      default:      case PROCESSOR_ARCHITECTURE_UNKNOWN: Architecture = L"Unknown";  break;      }   }

/* Create a YAML file describing the image encoded into a null terminated   string. Caller will own the memory.   */char *store_metadata_(struct PmemMemoryInfo *info){	SYSTEM_INFO sys_info;	struct tm newtime;	__time32_t aclock;	char time_buffer[32];	errno_t errNum;	char *arch = NULL;	_time32(&aclock);   // Get time in seconds.	_gmtime32_s(&newtime, &aclock);   // Convert time to struct tm form.	// Print local time as a string.	errNum = asctime_s(time_buffer, 32, &newtime);	if (errNum) {		time_buffer[0] = 0;	}	// Get basic architecture information (Note that we always write ELF64 core	// dumps - even on 32 bit platforms).	ZeroMemory(&sys_info, sizeof(sys_info));	GetNativeSystemInfo(&sys_info);	switch (sys_info.wProcessorArchitecture) {	case PROCESSOR_ARCHITECTURE_AMD64:		arch = "AMD64";		break;	case PROCESSOR_ARCHITECTURE_INTEL:		arch = "I386";		break;	default:		arch = "Unknown";	}	char *buffer = (char *)malloc(1000);	_snprintf_s(buffer, 1000, _TRUNCATE,		// A YAML File describing metadata about this image.		"# PMEM/n"		"---/n"   // The start of the YAML file.		"acquisition_tool: 'WinPMEM " PMEM_VERSION "'/n"		"acquisition_timestamp: %s/n"		"CR3: %#llx/n"		"NtBuildNumber: %#llx/n"		"NtBuildNumberAddr: %#llx/n"		"KernBase: %#llx/n"		"Arch: %s/n"		".../n",  // This is the end of a YAML file.		time_buffer,		info->CR3.QuadPart,		info->NtBuildNumber.QuadPart,		info->NtBuildNumberAddr.QuadPart,		info->KernBase.QuadPart,		arch	);	return buffer;};

/*** CPU ***/unsigned vlc_GetCPUCount (void){    SYSTEM_INFO systemInfo;    GetNativeSystemInfo(&systemInfo);    return systemInfo.dwNumberOfProcessors;}

intcpu_count(){  SYSTEM_INFO si;  GetNativeSystemInfo( &si );  return (int)si.dwNumberOfProcessors;}

/// <summary>/// Capture stack frames/// </summary>/// <param name="ip">Current instruction pointer</param>/// <param name="sp">Current stack pointer</param>/// <param name="results">Found frames.</param>/// <param name="depth">Frame depth limit</param>/// <returns>Number of found frames</returns>size_t TraceHook::StackBacktrace( uintptr_t ip, uintptr_t sp, vecStackFrames& results, uintptr_t depth /*= 10 */ ){    SYSTEM_INFO sysinfo = { 0 };    uintptr_t stack_base = (uintptr_t)((PNT_TIB)NtCurrentTeb())->StackBase;    GetNativeSystemInfo( &sysinfo );    // Store exception address    results.emplace_back( std::make_pair( 0, ip ) );    // Walk stack    for (uintptr_t stackPtr = sp; stackPtr < stack_base && results.size() <= depth; stackPtr += sizeof(void*))    {        uintptr_t stack_val = *(uintptr_t*)stackPtr;        MEMORY_BASIC_INFORMATION meminfo = { 0 };        // Decode value        uintptr_t original = stack_val & HIGHEST_BIT_UNSET;        // Invalid value        if ( original < (uintptr_t)sysinfo.lpMinimumApplicationAddress ||             original > (uintptr_t)sysinfo.lpMaximumApplicationAddress)        {            continue;        }        // Check if memory is executable        if (VirtualQuery( (LPVOID)original, &meminfo, sizeof(meminfo) ) != sizeof(meminfo))            continue;        if ( meminfo.Protect != PAGE_EXECUTE_READ &&             meminfo.Protect != PAGE_EXECUTE_WRITECOPY &&             meminfo.Protect != PAGE_EXECUTE_READWRITE)        {            continue;        }        // Detect 'call' instruction        for (uintptr_t j = 1; j < 8; j++)        {            DISASM info = { 0 };            info.EIP = original - j;        #ifdef _M_AMD64            info.Archi = 64;        #endif              if (Disasm( &info ) > 0 && info.Instruction.BranchType == CallType)            {                results.emplace_back( std::make_pair( stackPtr, stack_val ) );                break;            }        }    }    return results.size();}

int iam32on64 (){  SYSTEM_INFO sysinfo_32, sysinfo_64;  sysinfo_32.wProcessorArchitecture = 0;  sysinfo_64.wProcessorArchitecture = 0;  GetNativeSystemInfo (&sysinfo_64);  GetSystemInfo (&sysinfo_32);  return sysinfo_64.wProcessorArchitecture != sysinfo_32.wProcessorArchitecture && sysinfo_64.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64;}

static app_mode_t get_app_mode() {    SYSTEM_INFO sys_info;    GetNativeSystemInfo(&sys_info);    if (sys_info.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL) {        return MODE_X86;    } else if (sys_info.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) {        return MODE_X64;    }    return MODE_UNKNOWN;}

VOID GetSystemCPU(WCHAR *szBuffer){    SYSTEM_INFO archInfo;    ISWOW64PROC fnIsWow64Process;    BOOL isWow64 = FALSE;    /* Find out if the program is running through WOW64 or not. Apparently,    IsWow64Process() is not available on all versions of Windows, so the function    has to be imported at runtime. If the function cannot be found, then assume    the program is not running in WOW64. */    fnIsWow64Process = (ISWOW64PROC)GetProcAddress(        GetModuleHandleW(L"kernel32"), "IsWow64Process");        if (fnIsWow64Process != NULL)        fnIsWow64Process(GetCurrentProcess(), &isWow64);    /* If the program is compiled as 32-bit, but is running in WOW64, it will    automatically report as 32-bit regardless of the actual system architecture.    It detects whether or not the program is using WOW64 or not, and then    uses GetNativeSystemInfo(). If it is, it will properly report the actual    system architecture to the user. */    if (isWow64)        GetNativeSystemInfo(&archInfo);    else        GetSystemInfo(&archInfo);    /* Now check to see what the system architecture is */    if(archInfo.wProcessorArchitecture != PROCESSOR_ARCHITECTURE_UNKNOWN)    {        switch(archInfo.wProcessorArchitecture)        {        case PROCESSOR_ARCHITECTURE_INTEL:        {            wsprintfW(szBuffer, L"32-bit");            break;        }        case PROCESSOR_ARCHITECTURE_AMD64:        {            wsprintfW(szBuffer, L"64-bit");            break;        }        case PROCESSOR_ARCHITECTURE_IA64:        {            wsprintfW(szBuffer, L"Itanium");            break;        }        case PROCESSOR_ARCHITECTURE_ARM:        {            wsprintfW(szBuffer, L"ARM");            break;        }        default:break;        }    }}

void main(){    GetNativeSystemInfo(&sysInfo); // 64bit    dectectOS();//    if(sysInfo.dwOemId) {printf("/nOEM ID : %s", sysInfo.dwOemId);}    idProcessorArchitecture(); // get CPU ARCHITECTURE    printf("/nNumber of Logical Processors : %d", sysInfo.dwNumberOfProcessors);    currentSystemMemoryInformation();}

BOOL is64(){	SYSTEM_INFO si;	GetNativeSystemInfo(&si);	if (si.wProcessorArchitecture && PROCESSOR_ARCHITECTURE_INTEL)		return FALSE;	else		return TRUE;}

bool is64(){	SYSTEM_INFO si;	GetNativeSystemInfo(&si);	if (si.wProcessorArchitecture && PROCESSOR_ARCHITECTURE_INTEL)		return false;	else		return true;}

/*********************************************************************************   函 数 名 : GetOSBit*  功能描述 : 取得操作系统位数*  参数列表 : 无*   说      明 : *  返回结果 :  如果成功，返回操作系统位数, 否则返回0********************************************************************************/ULONG   GetOSBit(VOID){        SYSTEM_INFO si = {0} ;        GetNativeSystemInfo(&si) ;        if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64 ||                si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_IA64 )        {                return 64;        }        return 32;}

QTCREATOR_UTILS_EXPORT bool is64BitWindowsSystem(){#ifdef Q_OS_WIN    SYSTEM_INFO systemInfo;    GetNativeSystemInfo(&systemInfo);    return systemInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64            || systemInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_IA64;#else    return false;#endif}

static int get_cpu_count(){    int core_count = 16;#if HAVE_UNISTD_H && !defined(__OS2__)#if defined(_SC_NPROCESSORS_ONLN)    core_count = sysconf(_SC_NPROCESSORS_ONLN);#elif defined(_SC_NPROC_ONLN)    core_count = sysconf(_SC_NPROC_ONLN);#endif#elif defined(_WIN32)    {#if _WIN32_WINNT >= 0x0501        SYSTEM_INFO sysinfo;        GetNativeSystemInfo(&sysinfo);#else        PGNSI pGNSI;        SYSTEM_INFO sysinfo;        /* Call GetNativeSystemInfo if supported or         * GetSystemInfo otherwise. */        pGNSI = (PGNSI) GetProcAddress(                GetModuleHandle(TEXT("kernel32.dll")), "GetNativeSystemInfo");        if (pGNSI != NULL)            pGNSI(&sysinfo);        else            GetSystemInfo(&sysinfo);#endif        core_count = sysinfo.dwNumberOfProcessors;    }#elif defined(__OS2__)    {        ULONG proc_id;        ULONG status;        core_count = 0;        for (proc_id = 1; ; proc_id++)        {            if (DosGetProcessorStatus(proc_id, &status))                break;            if (status == PROC_ONLINE)                core_count++;        }    }#else    /* other platforms */#endif    return core_count > 0 ? core_count : 1;}

Native::Native( HANDLE hProcess, bool x86OS /*= false*/ )    : _hProcess( hProcess ){    SYSTEM_INFO info = { { 0 } };    GetNativeSystemInfo( &info );    _pageSize = info.dwPageSize;    // x86 OS, emulate WOW64 processes    if (x86OS)    {        _wowBarrier.sourceWow64 = true;        _wowBarrier.targetWow64 = true;        _wowBarrier.type = wow_32_32;        _wowBarrier.x86OS = true;    }    else    {        BOOL wowSrc = FALSE, wowTgt = FALSE;        IsWow64Process( GetCurrentProcess(), &wowSrc );        IsWow64Process( _hProcess, &wowTgt );        _wowBarrier.sourceWow64 = (wowSrc == TRUE);        _wowBarrier.targetWow64 = (wowTgt == TRUE);        if (wowSrc == TRUE && wowTgt == TRUE)            _wowBarrier.type = wow_32_32;        else if (wowSrc == FALSE && wowTgt == FALSE)            _wowBarrier.type = wow_64_64;        else if (wowSrc == TRUE)            _wowBarrier.type = wow_32_64;        else            _wowBarrier.type = wow_64_32;    }    HMODULE hNtdll = GetModuleHandleW( L"ntdll.dll" );    HMODULE hKernel32 = GetModuleHandleW( L"kernel32.dll" );        DynImport::load( "NtQueryInformationProcess",  hNtdll );    DynImport::load( "NtSetInformationProcess",    hNtdll );    DynImport::load( "NtQueryInformationThread",   hNtdll );    DynImport::load( "NtDuplicateObject",          hNtdll );    DynImport::load( "NtQueryObject",              hNtdll );      DynImport::load( "NtQuerySection",             hNtdll );    DynImport::load( "RtlCreateActivationContext", hNtdll );    DynImport::load( "NtQueryVirtualMemory",       hNtdll );    DynImport::load( "NtCreateThreadEx",           hNtdll );    DynImport::load( "NtLockVirtualMemory",        hNtdll );    DynImport::load( "NtSuspendProcess",           hNtdll );    DynImport::load( "NtResumeProcess",            hNtdll );    DynImport::load( "Wow64GetThreadContext",      hKernel32 );    DynImport::load( "Wow64SetThreadContext",      hKernel32 );    DynImport::load( "Wow64SuspendThread",         hKernel32 );    }

PerformanceMonitor::PerformanceMonitor(){    HANDLE thisProcessHande = GetCurrentProcess();    SYSTEM_INFO sysInfo;    BOOL runningInWow64 = false;    IsWow64Process(thisProcessHande, &runningInWow64);    if(runningInWow64){        GetNativeSystemInfo(&sysInfo);    }    else{        GetSystemInfo(&sysInfo);    }    this->processorsCount = sysInfo.dwNumberOfProcessors;}

/* * Returns 1 if the operating system is a 64-bit version of * Windows. */int NaClOsIs64BitWindows() {  SYSTEM_INFO system_info;  GetNativeSystemInfo(&system_info);  if (PROCESSOR_ARCHITECTURE_AMD64 == system_info.wProcessorArchitecture) {    /*     * The installed operating system processor architecture is x86-64.     * This assumes the caller already knows it's a supported architecture.     */    return 1;  }  return 0;}

const std::string& CSysInfo::GetKernelCpuFamily(void){  static std::string kernelCpuFamily;  if (kernelCpuFamily.empty())  {#ifdef TARGET_WINDOWS    SYSTEM_INFO si;    GetNativeSystemInfo(&si);    if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL ||        si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)        kernelCpuFamily = "x86";    else if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_ARM)      kernelCpuFamily = "ARM";#elif defined(TARGET_DARWIN)    const NXArchInfo* archInfo = NXGetLocalArchInfo();    if (archInfo)    {      const cpu_type_t cpuType = (archInfo->cputype & ~CPU_ARCH_ABI64); // get CPU family without 64-bit ABI flag      if (cpuType == CPU_TYPE_I386)        kernelCpuFamily = "x86";      else if (cpuType == CPU_TYPE_ARM)        kernelCpuFamily = "ARM";      else if (cpuType == CPU_TYPE_POWERPC)        kernelCpuFamily = "PowerPC";#ifdef CPU_TYPE_MIPS      else if (cpuType == CPU_TYPE_MIPS)        kernelCpuFamily = "MIPS";#endif // CPU_TYPE_MIPS    }#elif defined(TARGET_POSIX)    struct utsname un;    if (uname(&un) == 0)    {      std::string machine(un.machine);      if (machine.compare(0, 3, "arm", 3) == 0 || machine.compare(0, 7, "aarch64", 7) == 0)        kernelCpuFamily = "ARM";      else if (machine.compare(0, 4, "mips", 4) == 0)        kernelCpuFamily = "MIPS";      else if (machine.compare(0, 4, "i686", 4) == 0 || machine == "i386" || machine == "amd64" ||  machine.compare(0, 3, "x86", 3) == 0)        kernelCpuFamily = "x86";      else if (machine.compare(0, 4, "s390", 4) == 0)        kernelCpuFamily = "s390";      else if (machine.compare(0, 3, "ppc", 3) == 0 || machine.compare(0, 5, "power", 5) == 0)        kernelCpuFamily = "PowerPC";    }#endif    if (kernelCpuFamily.empty())      kernelCpuFamily = "unknown CPU family";  }  return kernelCpuFamily;}

static void initialize_hardware_concurrency_info () {#if __TBB_WIN8UI_SUPPORT    // For these applications processor groups info is unavailable    // Setting up a number of processors for one processor group    theProcessorGroups[0].numProcs = theProcessorGroups[0].numProcsRunningTotal = std::thread::hardware_concurrency();#else /* __TBB_WIN8UI_SUPPORT */    dynamic_link( "Kernel32.dll", ProcessorGroupsApiLinkTable,                  sizeof(ProcessorGroupsApiLinkTable)/sizeof(dynamic_link_descriptor) );    SYSTEM_INFO si;    GetNativeSystemInfo(&si);    DWORD_PTR pam, sam, m = 1;    GetProcessAffinityMask( GetCurrentProcess(), &pam, &sam );    int nproc = 0;    for ( size_t i = 0; i < sizeof(DWORD_PTR) * CHAR_BIT; ++i, m <<= 1 ) {        if ( pam & m )            ++nproc;    }    __TBB_ASSERT( nproc <= (int)si.dwNumberOfProcessors, NULL );    // By default setting up a number of processors for one processor group    theProcessorGroups[0].numProcs = theProcessorGroups[0].numProcsRunningTotal = nproc;    // Setting up processor groups in case the process does not restrict affinity mask and more than one processor group is present    if ( nproc == (int)si.dwNumberOfProcessors && TBB_GetActiveProcessorCount ) {        // The process does not have restricting affinity mask and multiple processor groups are possible        ProcessorGroupInfo::NumGroups = (int)TBB_GetActiveProcessorGroupCount();        __TBB_ASSERT( ProcessorGroupInfo::NumGroups <= MaxProcessorGroups, NULL );        // Fail safety bootstrap. Release versions will limit available concurrency        // level, while debug ones would assert.        if ( ProcessorGroupInfo::NumGroups > MaxProcessorGroups )            ProcessorGroupInfo::NumGroups = MaxProcessorGroups;        if ( ProcessorGroupInfo::NumGroups > 1 ) {            TBB_GROUP_AFFINITY ga;            if ( TBB_GetThreadGroupAffinity( GetCurrentThread(), &ga ) )                ProcessorGroupInfo::HoleIndex = ga.Group;            int nprocs = 0;            for ( WORD i = 0; i < ProcessorGroupInfo::NumGroups; ++i ) {                ProcessorGroupInfo  &pgi = theProcessorGroups[i];                pgi.numProcs = (int)TBB_GetActiveProcessorCount(i);                __TBB_ASSERT( pgi.numProcs <= (int)sizeof(DWORD_PTR) * CHAR_BIT, NULL );                pgi.mask = pgi.numProcs == sizeof(DWORD_PTR) * CHAR_BIT ? ~(DWORD_PTR)0 : (DWORD_PTR(1) << pgi.numProcs) - 1;                pgi.numProcsRunningTotal = nprocs += pgi.numProcs;            }            __TBB_ASSERT( nprocs == (int)TBB_GetActiveProcessorCount( TBB_ALL_PROCESSOR_GROUPS ), NULL );        }    }#endif /* __TBB_WIN8UI_SUPPORT */    PrintExtraVersionInfo("Processor groups", "%d", ProcessorGroupInfo::NumGroups);    if (ProcessorGroupInfo::NumGroups>1)        for (int i=0; i<ProcessorGroupInfo::NumGroups; ++i)            PrintExtraVersionInfo( "----- Group", "%d: size %d", i, theProcessorGroups[i].numProcs);}

         _WIN32             indicates 64-bit or 32-bit Windows         _MSC_VER           indicates Microsoft C compiler         !WIN_KERNEL_BUILD  indicates Windows user-mode*/ unsigned int                          abstraction_cpu_count (