SHORTREAL_SIZE=32 vs 64 performances

[ndtrung81]

Hi HOOMD developers,

I built 2 versions of HOOMD 5.1.1 with CUDA 12.2, one with HOOMD_SHORTREAL_SIZE=32 and the other with HOOMD_SHORTREAL_SIZE=64, keeping HOOMD_LONGREAL_SIZE=64. When I ran a simulation of a polymer melt with 56,000 particles for 50,000 steps, there is no difference in performance between the 2 versions, both are about 4520 TPS on an A100 GPU. Is it expected that the performances would be that imilar? I expected that the HOOMD_SHORTREAL_SIZE=32 version would be faster.

Is there a way to print out the precision modes of the builds to the log or the notice file to ascertain that I don't mess up the versions?

Thanks,
-Trung

[mphoward]

I think this is what you want to check the values of those quantities from the build:

https://hoomd-blue.readthedocs.io/en/v5.2.0/hoomd/module-version.html#hoomd.version.floating_point_precision

However, I think what you're seeing is probably correct. Most of HOOMD uses the Scalar typedef for floating-point values, and the precision of Scalar is determined by HOOMD_LONGREAL_SIZE:

hoomd-blue/hoomd/HOOMDMath.h

Lines 52 to 84 in 6e17a1e

	#if HOOMD_LONGREAL_SIZE == 32
	//! Floating point type (single precision)
	typedef float Scalar;
	//! Floating point type with x,y elements (single precision)
	typedef float2 Scalar2;
	//! Floating point type with x,y elements (single precision)
	typedef float3 Scalar3;
	//! Floating point type with x,y,z,w elements (single precision)
	typedef float4 Scalar4;
	typedef float LongReal;
	typedef float2 LongReal2;
	typedef float3 LongReal3;
	typedef float4 LongReal4;
	#elif HOOMD_LONGREAL_SIZE == 64
	//! Floating point type (double precision)
	typedef double Scalar;
	//! Floating point type with x,y elements (double precision)
	typedef double2 Scalar2;
	//! Floating point type with x,y,z elements (double precision)
	typedef double3 Scalar3;
	//! Floating point type with x,y,z,w elements (double precision)
	typedef double4 Scalar4;
	typedef double LongReal;
	typedef double2 LongReal2;
	typedef double3 LongReal3;
	typedef double4 LongReal4;
	#else
	#error HOOMD_LONGREAL_SIZE must be 32 or 64.
	#endif

(i.e., Scalar and LongReal are synonyms.) I expect if you switch HOOMD_LONGREAL_SIZE to 32, you'll see a change in performance; however, note from the documentation:

NOT RECOMMENDED, HOOMD-blue fails validation tests when HOOMD_LONGREAL_SIZE == HOOMD_SHORTREAL_SIZE == 32.

[ndtrung81]

Cool, thanks @mphoward for the info with hoomd.version.floating_point_precision and for pointing out the relevant header file. The pair force kernel in hoomd/md/PotentialPairGPU.h indeed uses Scalar for all the operations and storing. The sentence in the Building page neverthelss indicates that HOOMD_SHORTREAL_SIZE When set to 32, perform force computations, overlap checks, and other local calculations in single precision.

I don't wish to use HOOMD_LONGREAL_SIZE = 32 anyway.

[joaander]

That note in the documentation is not accurate. It was written when I hoped to implement all those things in mixed precision. In practice, the cost of converting double->float and back again was much higher than the time saved by performing a few computations with floats. I reverted the changes because overall performance was lower.

Currently, the only part of hoomd that uses ShortReal is hpmc.