¿Cómo puedo descubrir si mi CPU es de 32 o 64 bits?

Question

¿Cómo puedo saber si mi procesador es de 32 o 64 bits (en el idioma que elija)? Quiero saber esto para los procesadores Intel y 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

C #, agnóstico del sistema operativo

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

Esto es algo crudo, pero básicamente le dice si el CLR se está ejecutando como 32 bits o 64 bits, lo que es más probable que necesite saber. El CLR puede ejecutarse como 32 bits en un procesador de 64 bits, por ejemplo.

Para obtener más información, consulte aquí: Cómo detectar Windows ¿Plataforma de 64 bits con .NET?

Answer 3

El bit difícil aquí es que puede tener una CPU de 64 bits pero un sistema operativo de 32 bits. Si le importa ese caso, necesitará un talón de ASM para interrogar a la CPU. Si no, puedes preguntar al sistema operativo fácilmente.

Answer 4

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

C #

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

PowerShell

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

Answer 5

En Python:

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

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

Puedes tener más infos 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 vivo :-)

Answer 6

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 solución posible para Windows Script Host, esta vez en JScript y utilizando 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 7

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 8

Código C #:

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

Answer 9

En Linux puede determinar el " bitness " leyendo

/proc/cpuinfo

por ejemplo.

cat /proc/cpuinfo | grep flags

si contiene el

lm

marca que es una CPU x86 de 64 bits (incluso si tienes instalado Linux de 32 bits)

No estoy seguro de si esto funciona también para CPU que no sean x86, como PPC o ARM.