Comment puis-je savoir si mon processeur est en 32 ou 64 bits?

Question

Comment puis-je savoir si mon processeur est 32 bits ou 64 bits (dans la langue de votre choix)? Je veux savoir ceci pour les processeurs Intel et 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

Je pensais, sur un processeur 64 bits, les pointeurs sont 64 bits. Ainsi, au lieu de vérifier les fonctionnalités du processeur, il est peut-être possible d'utiliser des pointeurs pour le 'tester' par programmation. Cela pourrait être aussi simple que de créer une structure avec deux pointeurs contigus, puis de vérifier leur «foulée».

Answer 3

C#, OS agnostique

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

C'est un peu brut mais vous indique essentiellement que le CLR est en cours d'exécution en 32 bits ou 64 bits, ce qui est plus probablement ce que vous devez savoir. Le CLR peut fonctionner en 32 bits sur un processeur 64 bits, par exemple.

Pour plus d'informations, voir ici: How to detect Windows 64-bit platform with .NET?

Answer 4

Le peu délicat ici est que vous pourriez avoir un 64 bit CPU, mais un système d'exploitation 32 bits. Si vous vous souciez de ce cas, il faudra un astérisque pour interroger le CPU. Sinon, vous pouvez demander l'OS facilement.

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 

Une autre solution possible pour Windows Script Host, cette fois dans JScript et en utilisant la variable d'environnement 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

Dans .NET vous pouvez différencier x86 de 64 bits en regardant la propriété Size de la structure IntPtr. La propriété IntPtr.Size est retournée en octets, 8 bits par octet donc elle est égale à 4 sur un processeur 32 bits et 8 sur un processeur 64 bits. Puisque nous parlons de processeurs 32 bits et 64 bits plutôt que de processeurs 4 octets ou 8 octets, j'aime faire la comparaison en bits, ce qui rend plus clair ce qui se passe.

C#

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

PowerShell

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

Answer 7

C# Code:

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') 

Comme d'habitude, assez soigné. Mais je suis à peu près sûr que ces fonctions renvoient la plate-forme où l'exec a été construit, pas les plates-formes sur lesquelles il s'exécute. Il y a encore une petite chance qu'un geek lance une version 32 bits sur un ordinateur 64 bits.

Vous pouvez avoir plus d'infos comme:

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.

Cela ressemble plus à des données en direct :-)

Answer 9

Sous Linux, vous pouvez déterminer le "bitness" en lisant

/proc/cpuinfo 

par exemple.

cat /proc/cpuinfo | grep flags 

si elle contient le

lm 

drapeau il est un x86 64 bit CPU (même si vous avez 32 linux bits installé)

Je ne sais pas si cela fonctionne pour les processeurs non x86 et tels que PPC ou ARM.