¿Cómo puedo saber si mi CPU tiene 32 o 64 bits?

Question

¿Cómo puedo saber si mi procesador es de 32 bits o de 64 bits (en el idioma de su elección)? Quiero saber esto para los procesadores Intel y AMD.

Answer 1

de 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

que estaba pensando, en un procesador de 64 bits, los punteros son de 64 bits. Entonces, en lugar de verificar las características del procesador, tal vez sea posible usar punteros para 'probarlo' programáticamente. Podría ser tan simple como crear una estructura con dos punteros contiguos y luego verificar su "zancada".

Answer 3

C#, OS agnóstico

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

Esto es algo tosco pero básicamente le indica si el CLR se ejecuta como de 32 bits o 64 bits, lo que es más probable que lo que se necesita saber. El CLR puede ejecutarse como 32 bits en un procesador de 64 bits, por ejemplo.

Para obtener más información, ver aquí: How to detect Windows 64-bit platform with .NET?

Answer 4

el truco aquí es que podría tener una CPU de 64 bits, pero un sistema operativo de 32 bits. Si te preocupa ese caso, va a necesitar un asm para interrogar a la CPU. De lo contrario, puede solicitar el sistema operativo fácilmente.

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 

Otra posible solución para Windows Script Host, esta vez en JScript y el uso de la variable de entorno 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

En .NET se puede diferenciar x 86 x 64 de mirando la propiedad Tamaño de la estructura IntPtr. La propiedad IntPtr.Size se devuelve en bytes, 8 bits por byte, por lo que equivale a 4 en una CPU de 32 bits y 8 en una CPU de 64 bits. Como hablamos de procesadores de 32 bits y de 64 bits en lugar de procesadores de 4 bytes u 8 bytes, me gusta hacer la comparación en bits, lo que deja más claro lo que está sucediendo.

C#

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

PowerShell

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

Answer 7

C# Código:

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

Answer 8

En Python:

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

Como de costumbre, bastante limpio. Pero estoy bastante seguro de que estas funciones devuelven la plataforma donde se ha construido el ejecutor, no las plataformas en las que se ejecuta. Todavía hay una pequeña posibilidad de que algún geek ejecute una versión de 32 bits en una computadora de 64 bits.

Puede tener algunos más informaciones como:

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.

Esto se parece más a datos en tiempo real :-)

Answer 9

En Linux se puede determinar el "valor de bits" mediante la lectura de

/proc/cpuinfo 

por ejemplo.

cat /proc/cpuinfo | grep flags 

si contiene la bandera

lm 

es un bit CPU x86 de 64 (incluso si tiene instalado 32 bit Linux)

No estoy seguro si esto funciona para las CPU no x86, así como PPC o ARM.