Home/ Questions/Q 3320034
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-05-17T22:53:42+00:00

I’m using atomic operations on counters, and I care about performance. I know that

  • 0

I’m using atomic operations on counters, and I care about performance. I know that on the 64-bit platform incrementing a long can be done in one shot, instead it requires two instructions in 32-bit platforms

I have such a code fragment

#if X64
using COUNTER_TYPE = System.Int64;
#else
using COUNTER_TYPE = System.Int32;
#endif

But I define no X64 constant in my project’s configuration. I wonder if there is a way to determine via #if statements if we are compiling for the x64 or not. When I implement a circular queue, I want to force its size up to 4 billions elements when running on x86, but I may appreciate unlocking its size to long.MaxValue when on x64. I know that on modern processors one or two instructions don’t really care, but it’s still my curiosity to know if I can detect the configuration via code without redefining an x64 profile with such constant specified.

Thank you.

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    One way to do this is to use System.IntPtr, which already abstracts the “bitness” of the assembly.

    Note that by default, the C# compiler compiles for “anycpu” which means that the bitness of the assembly at runtime is determined by the bitness of the process into which it is loaded. For executable assemblies, this is x86 for 32 bit OS and x64 for 64 bit OS.

    There are 3 equivalent ways to get the size of IntPtr:

    // Use the static property
var size = IntPtr.Size;

// Use Marshal
var size = System.Runtime.InteropServices.Marshal.SizeOf(typeof(IntPtr));

// Use unsafe with sizeof
unsafe
{
    var size = sizeof(IntPtr);
}

    I can’t see any reason not to use the static property for all cases, since it is easiest.

    • 0