CODEWITHSUNDEEP
language-agnosticprocessor
ilias
ilias

Reputation: 2682

How can I discover whether my CPU is 32 or 64 bits?

How do I find out if my processor is 32 bit or 64 bit (in your language of choice)? I want to know this for both Intel and AMD processors.

Upvotes: 12

Views: 3446

Answers (9)

Helen
Helen

Reputation: 97540

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

Another possible solution for Windows Script Host, this time in JScript and using the PROCESSOR_ARCHITECTURE environment variable:

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
}

Upvotes: 1

plinth
plinth

Reputation: 49179

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

Upvotes: 21

Ben Schwehn
Ben Schwehn

Reputation: 4565

In linux you can determine the "bitness" by reading 

/proc/cpuinfo

eg. 

cat /proc/cpuinfo | grep flags

if it contains the 

lm

flag it's a x86 64 bit CPU (even if you have 32 bit linux installed)

Not sure if this works for non x86 CPUs as well such as PPC or ARM.

Upvotes: 0

Bite code
Bite code

Reputation: 596583

In Python :

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

As usual, pretty neat. But I'm pretty sure these functions return the platform where the exec has been built, not the the platforms it running on. There is still a small chance that some geek is running a 32 bits version on a 64 bits computer.

You can have some more infos like : 

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.

This looks more like live data :-)

Upvotes: 1

Brian Reiter
Brian Reiter

Reputation: 1359

In .NET you can differentiate x86 from x64 by looking at the Size property of the IntPtr structure. The IntPtr.Size property is returned in bytes, 8 bits per byte so it is equal to 4 on a 32-bit CPU and 8 on a 64-bit CPU. Since we talk about 32-bit and 64-bit processors rather than 4-byte or 8-byte processors, I like to do the comparison in bits which makes it more clear what is going on.

C#

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

PowerShell

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

Upvotes: 2

NinethSense
NinethSense

Reputation: 9028

C# Code:

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

Upvotes: 0

Joshua
Joshua

Reputation: 43188

The tricky bit here is you might have a 64 bit CPU but a 32 bit OS. If you care about that case it is going to require an asm stub to interrogate the CPU. If not, you can ask the OS easily.

Upvotes: 4

Matt Howells
Matt Howells

Reputation: 41266

C#, OS agnostic

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

This is somewhat crude but basically tells you whether the CLR is running as 32-bit or 64-bit, which is more likely what you would need to know. The CLR can run as 32-bit on a 64-bit processor, for example.

For more information, see here: How to detect Windows 64-bit platform with .NET?

Upvotes: 9

sybreon
sybreon

Reputation: 3156

I was thinking, on a 64-bit processor, pointers are 64-bit. So, instead of checking processor features, it maybe possible to use pointers to 'test' it programmatically. It could be as simple as creating a structure with two contiguous pointers and then checking their 'stride'.

Upvotes: 0

Related Questions