Jak mogę sprawdzić, czy mój procesor ma 32 lub 64 bity?

Question

Jak mogę się dowiedzieć, czy mój procesor jest 32-bitowy czy 64-bitowy (w wybranym języku)? Chcę to wiedzieć zarówno dla procesorów Intel, jak i AMD.

Answer 1

Windows C/C++:

#include <windows.h> 

SYSTEM_INFO sysInfo, *lpInfo; 
lpInfo = &sysInfo; 
::GetSystemInfo(lpInfo); 
switch (lpInfo->wProcessorArchitecture) { 
case PROCESSOR_ARCHITECTURE_AMD64: 
case PROCESSOR_ARCHITECTURE_IA64: 
    // 64 bit 
    break; 
case PROCESSOR_ARCHITECTURE_INTEL: 
    // 32 bit 
    break; 
case PROCESSOR_ARCHITECTURE_UNKNOWN: 
default: 
    // something else 
    break; 
} 

Answer 2

Myślałam, na procesor 64-bitowy, wskaźniki są 64-bitowe. Dlatego zamiast sprawdzać funkcje procesora, możliwe jest użycie wskaźników do "testowania" go programowo. Może to być tak proste, jak utworzenie struktury z dwoma sąsiednimi wskaźnikami, a następnie sprawdzenie ich "kroku".

Answer 3

C#, OS agnostyk

sizeof(IntPtr) == 4 ? "32-bit" : "64-bit" 

Jest to nieco surowy, ale w zasadzie wskazuje, czy CLR pracuje jako 32-bitową lub 64-bitową, co jest bardziej prawdopodobne, co trzeba wiedzieć. Środowisko CLR może działać na przykład jako 32-bitowy procesor 64-bitowy.

Aby uzyskać więcej informacji, zobacz tutaj: How to detect Windows 64-bit platform with .NET?

Answer 4

Tricky nieco tutaj jest może masz 64 bitowy procesor, ale 32-bitowy system operacyjny. Jeśli zależy Ci na tym przypadku, będzie wymagać asm-stub do przesłuchania procesora. Jeśli nie, możesz łatwo poprosić system operacyjny.

Answer 5

VBScript, Windows:

Const PROCESSOR_ARCHITECTURE_X86 = 0 
Const PROCESSOR_ARCHITECTURE_IA64 = 6 
Const PROCESSOR_ARCHITECTURE_X64 = 9 

strComputer = "." 

Set oWMIService = GetObject("winmgmts:" & _ 
    "{impersonationLevel=impersonate}!\\" & strComputer & "\root\cimv2") 

Set colProcessors = oWMIService.ExecQuery("SELECT * FROM Win32_Processor") 

For Each oProcessor In colProcessors 
    Select Case oProcessor.Architecture 
    Case PROCESSOR_ARCHITECTURE_X86 
     ' 32-bit 
    Case PROCESSOR_ARCHITECTURE_X64, PROCESSOR_ARCHITECTURE_IA64 
     ' 64-bit 
    Case Else 
     ' other 
    End Select 
Next 

Innym możliwym rozwiązaniem dla Windows Script Host, tym razem w JScript i za pomocą zmiennej środowiskowej PROCESSOR_ARCHITECTURE:

var oShell = WScript.CreateObject("WScript.Shell"); 
var oEnv = oShell.Environment("System"); 
switch (oEnv("PROCESSOR_ARCHITECTURE").toLowerCase()) 
{ 
    case "x86": 
    // 32-bit 
    case "amd64": 
    // 64-bit 
    default: 
    // other 
} 

Answer 6

W .NET można odróżnić od x64 x86 patrząc na właściwość Size struktury IntPtr. Właściwość IntPtr.Size jest zwracana w bajtach, 8 bitów na bajt, więc jest równa 4 na 32-bitowym CPU i 8 na 64-bitowym CPU. Ponieważ mówimy o procesorach 32-bitowych i 64-bitowych zamiast 4-bajtowych lub 8-bajtowych procesorach, lubię porównywać je w bitach, co sprawia, że ​​jest bardziej zrozumiałe, co się dzieje.

C#

if(IntPtr.Size * 8 == 64) 
{ 
    //x64 code 
} 

PowerShell

if([IntPtr]::Size * 8 -eq 64) 
{ 
    #x64 code 
} 

Answer 7

C# Kod:

int size = Marshal.SizeOf(typeof(IntPtr)); 
if (size == 8) 
{ 
Text = "64 bit"; 
} 
else if (size == 4) 
{ 
Text = "32 bit"; 
} 

Answer 8

W Pythonie:

In [10]: import platform 
In [11]: platform.architecture() 
Out[11]: ('32bit', 'ELF') 

Jak zwykle całkiem schludnie. Ale jestem pewien, że te funkcje zwracają platformę, na której zbudowano exec, a nie platformy, na których działa. Nadal istnieje mała szansa, że ​​jakiś geek używa wersji 32-bitowej na 64-bitowym komputerze.

Możesz mieć trochę więcej infos jak:

In [13]: platform.system() 
Out[13]: 'Linux' 

In [19]: platform.uname() 
Out[19]: 
('Linux', 
'asus-u6', 
'2.6.28-11-generic', 
'#42-Ubuntu SMP Fri Apr 17 01:57:59 UTC 2009', 
'i686', 
'') 

ETC.

To wygląda bardziej jak dane żywo :-)

Answer 9

w Linuksie można określić "bitness" czytając

/proc/cpuinfo 

np.

cat /proc/cpuinfo | grep flags 

jeśli zawiera

lm 

flagi Jest to x86 64-bitowy procesor (nawet jeśli masz zainstalowany 32-bitowy Linux)

nie wiem, czy to działa dla niezarejestrowanych procesorów x86, jak również takie jak PPC lub ARM.