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

StackOverflow https://stackoverflow.com/questions/824877

  •  05-07-2019
  •  | 
  •  

Question

Comment savoir si mon processeur est 32 bits ou 64 bits (dans la langue de votre choix)? Je veux savoir cela à la fois pour les processeurs Intel et AMD.

Était-ce utile?

La solution

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;
}

Autres conseils

C #, agnostique OS 

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

C’est un peu brutal, mais vous indique en gros si le CLR fonctionne en 32 bits ou en 64 bits, ce qui est probablement ce que vous auriez besoin de savoir. Le CLR peut par exemple fonctionner en 32 bits sur un processeur 64 bits.

Pour plus d'informations, voir ici: Comment détecter Windows Plateforme 64 bits avec .NET?

Le problème, c’est que vous pourriez avoir un processeur 64 bits mais un système d’exploitation 32 bits. Si vous vous souciez de ce cas, il faudra un stub asm pour interroger la CPU. Sinon, vous pouvez facilement demander au système d'exploitation.

Dans .NET, vous pouvez différencier x86 de x64 en consultant la propriété Size de la structure IntPtr. Propriété IntPtr.Size est renvoyé en octets, 8 bits par octet, il est donc égal à 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 bien 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 
}

En Python: 

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

Comme d'habitude, plutôt chouette. Mais je suis sûr que ces fonctions renvoient la plate-forme sur laquelle l'exécutif a été construit, pas les plates-formes sur lesquelles elle s'exécute. Il y a encore une petite chance qu'un geek exécute une version 32 bits sur un ordinateur 64 bits.

Vous pouvez avoir d'autres informations telles que: 

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

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
}

Je pensais que, sur un processeur 64 bits, les pointeurs sont en 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 programme. Cela pourrait être aussi simple que de créer une structure avec deux pointeurs contigus, puis de vérifier leur "foulée".

Code C #: 

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

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

/proc/cpuinfo

par exemple. 

cat /proc/cpuinfo | grep flags

s'il contient le 

lm

indique qu'il s'agit d'un processeur x86 64 bits (même si vous avez installé linux 32 bits)

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

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top