argon2-opencl: rusticl misdetected as ancient AMD Catalyst, doesn't recognize asm

[Giger22]

Follow-up to
john -list=opencl-devices -dev=2

Platform #1 name: rusticl, version: OpenCL 3.0 
    Device #0 (2) name:     AMD Radeon RX 5700 XT (radeonsi, navi10, LLVM 21.1.6, DRM 3.64, 6.18.4-artix1-1)
    Device vendor:          AMD
    Device type:            GPU (LE)
    Device version:         OpenCL 3.0 
    OpenCL version support: OpenCL C 1.2 
    Driver version:         25.3.3-arch1.1 
    Native vector widths:   char 1, short 1, int 1, long 1
    Preferred vector width: char 1, short 1, int 1, long 1
    Global Memory:          8 GiB
    Local Memory:           64 KiB (Global)
    Constant Buffer size:   64 MiB
    Max memory alloc. size: 2047 MiB
    Max clock (MHz):        2100
    Profiling timer res.:   10 ns
    Max Work Group Size:    1024
    Parallel compute cores: 40
    Stream processors:      2560  (40 x 64)
    Speed index:            5376000

john --test --format=opencl

Device 2@arous: AMD Radeon RX 5700 XT (radeonsi, navi10, LLVM 21.1.6, DRM 3.64, 6.18.4-artix1-1)
Benchmarking: AndroidBackup-opencl [PBKDF2-SHA1 AES OpenCL]... LWS=32 GWS=655360 (20480 blocks) DONE
Speed for cost 1 (iteration count) of 10000
Raw:    184089 c/s real, 26214K c/s virtual

Benchmarking: agilekeychain-opencl, 1Password Agile Keychain [PBKDF2-SHA1 AES OpenCL]... LWS=512 GWS=20480 (40 blocks) DONE
Speed for cost 1 (iteration count) of 1000
Raw:    3102K c/s real, 41369K c/s virtual

Benchmarking: ansible-opencl, Ansible Vault [PBKDF2-SHA256 HMAC-SHA256 OpenCL]... LWS=32 GWS=81920 (2560 blocks) DONE
Speed for cost 1 (iteration count) of 10000
Raw:    159843 c/s real, 8192K c/s virtual

Benchmarking: argon2-opencl, Argon2 [BlaMka OpenCL]... Options used: -I opencl -cl-mad-enable -cl-std=CL1.2 -D__GPU__ -DDEVICE_INFO=522 -D__SIZEOF_HOST_SIZE_T__=8 -DDEV_VER_MAJOR=25 -DDEV_VER_MINOR=3 -D_OPENCL_COMPILER -DWARP_SIZE=64 -DSHARED_MEM_SIZE=65536 -DUSE_WARP_SHUFFLE=0 /usr/share/john/opencl/argon2_kernel.cl
Build time: 20.410 ms
Build log: input.cl:101:2: error: use of undeclared identifier 'asm'
  101 |         asm("" ::: "memory");
      |         ^~~
Error executing LLVM compilation action.

Error building kernel /usr/share/john/opencl/argon2_kernel.cl. DEVICE_INFO=522
0: OpenCL CL_BUILD_PROGRAM_FAILURE (-11) error in opencl_common.c:1338 - clBuildProgram

[solardiz]

We have this:

commit 62c27ff77466745b49cd310dd4a6bb8a5ab2c0c9
Author: Solar <solar@openwall.com>
Date:   Sat Dec 30 01:14:04 2023 +0100

    argon2-opencl: Use compiler barrier with ancient AMD drivers

diff --git a/run/opencl/argon2_kernel.cl b/run/opencl/argon2_kernel.cl
index 52bbd293a..3a3bb79e9 100644
--- a/run/opencl/argon2_kernel.cl
+++ b/run/opencl/argon2_kernel.cl
@@ -97,6 +97,8 @@ ulong u64_shuffle(ulong v, uint thread_src, uint thread, __local ulong *buf)
        // TODO: Test on other device types to add support
 #if !gpu_nvidia(DEVICE_INFO) && !gpu_amd(DEVICE_INFO)
        barrier(CLK_LOCAL_MEM_FENCE);
+#elif gpu_amd(DEVICE_INFO) && DEV_VER_MAJOR < 2500
+       asm("" ::: "memory");
 #endif
        return buf[thread_src];
 #endif

So it seems that rusticl is detected by us the same as ancient AMD Catalyst driver, which is wrong.

Also, theoretically we could need a compiler memory barrier on all drivers/backends, but there's no such thing in OpenCL - or is there? - and using barrier(CLK_LOCAL_MEM_FENCE); for this is unnecessary overhead (it is more than a compiler barrier).

[magnumripper]

DEV_VER_MAJOR is only 25 here so you could tell them apart that way but a better option is obviously to add PLATFORM_RUSTICL to our host magic and opencl_device_info.h.

As for a portable compiler barrier, there is none. Why is it needed at all? Our options are memory fence, atomics or volatile.

[solardiz]

As for a portable compiler barrier, there is none. Why is it needed at all?

We have:

        buf[thread] = v;
        // Another option instead of the barrier. Maybe worth testing on CPUs because
        // in C++ default atomic operations DO a memory barrier.
        // atom_xchg(buf + thread, v);

        // GPUs don't need this as their warp size is at least 32 and that's what we need
        // TODO: Test on other device types to add support
#if !gpu_nvidia(DEVICE_INFO) && !gpu_amd(DEVICE_INFO)
        barrier(CLK_LOCAL_MEM_FENCE);
#elif !__OS_X__ && gpu_amd(DEVICE_INFO) && DEV_VER_MAJOR < 2500
        asm("" ::: "memory");
#endif
        return buf[thread_src];

As I understand, we assume that buf[thread] = v; is instruction(s) issued to the hardware before return buf[thread_src];, but the compiler has no reliable way to see this dependency exists, so may generate code that reads buf[thread_src] in preparation for the return of this value before it writes to buf[thread].

[solardiz]

DEV_VER_MAJOR is only 25 here so you could tell them apart that way

Oh, thanks! Does this imply you currently have a setup where you're able to reproduce this issue?

[magnumripper]

DEV_VER_MAJOR is only 25 here so you could tell them apart that way

Oh, thanks! Does this imply you currently have a setup where you're able to reproduce this issue?

Sorry no, I meant "in this case". It's what is extracted from "Driver version: 25.3.3-arch1.1" and can also be seen in the "Options used" printed when it bails out. Maybe we can assume that anything below 1000 isn't AMD - or something like that? I'm not sure what recent AMD drivers use for major version though.

[magnumripper]

I don't understand the "GPUs don't need this as their warp size is at least 32 and that's what we need". Why does old AMD drivers need it then?

[solardiz]

can also be seen in the "Options used" printed when it bails out.

Oh, indeed. I missed this in the original post.

Maybe we can assume that anything below 1000 isn't AMD - or something like that?

I think "something like that" for the purpose of this specific check. It's not exactly trying to check AMD or not, it's checking for specific drivers/backends that both need a compiler memory barrier here and support asm - which currently happens to be AMD Catalyst.

Why does old AMD drivers need it then?

As I understand, any driver/backend could need a compiler barrier here. We're just lucky that we can get away without such barrier on most other drivers for AMD (and on NVIDIA we normally don't even reach into this code, using shuffle instructions instead).

[solardiz]

Maybe we can assume that anything below 1000 isn't AMD - or something like that?

I see we also have many other places, in other kernels and shared headers, where we enable various workarounds or tweaks for ancient AMD Catalyst when amd_gcn(DEVICE_INFO) && DEV_VER_MAJOR < 2500 or < 1912, etc. Some of those are obviously unneeded on other drivers, like this one:

#if amd_gcn(DEVICE_INFO) && DEV_VER_MAJOR < 1912
/* Bug seen with multiples of 8 */
#define ror64(x, n) (((n) != 8) ? opt_ror64(x, n) : rotate(x, (ulong)(64 - (n))))

I guess the above example would also benefit from && DEV_VER_MAJOR >= 1000.

For many others, it's just performance tweaks, and without benchmarking we have no idea which code version runs better (and whether all do run at all), so we can as well leave those checks as-is for now.

[magnumripper]

BTW I presume MESA has this exact problem too? It should identify as gpu_amd() and the version major is likely lower than 2500.

For a canonical fix to similar problems: We have macros for MESA, Apple and so on, but we should add AMD and NVIDIA too - and only set them when the actual platform/runtime is AMD or nvidia. So instead of blacklisting with !__OS_X__ you'd whitelist with AMD_DRIVER or whatever name/bit we'd use.

[magnumripper]

Another possibility is to have opencl_common.c try building a tiny program using inline asm, on device init. Define HAVE_ASM if supported. This could be used for all our inline asm stuff.

Currently for opencl_misc.h's AMD asm AMD-soecific stuff, we blacklist __MESA__ and also check for cl_amd_media_ops which disqualifies MacOS and perhaps some others... perhaps that would rule out rusticl as well?

[magnumripper]

@Giger22 please run john -list=opencl-devices -dev=2 -v:5 | grep extensions and post output here. The bumped verbosity will make it print all device extensions such as cl_amd_media_ops.