Numeric precision in structs on mobile devices

[gkjohnson]

Hello!

I've been doing some testing on my Android Pixel 3 device (Adreno 630 GPU) and I've noticed some oddities in the precision of numbers represented in structs. Specifically when running this fragment shader you can see that behavior is different when using an in as a struct member vs using an int:

// #define STRUCT_TEST

precision highp int;
struct TestStruct {
  highp int val;
};

void main() {
    
  #ifdef STRUCT_TEST
    
    // displays black
    TestStruct s;
    s.val = 1 << 20;
    gl_FragColor = vec4( s.val, s.val, s.val, 1.0 );

  #else

    // displays white
    int val = 1 << 20;
    gl_FragColor = vec4( val, val, val, 1.0 );

  #endif

}

I also put this test webpage together to try to understand the behavior I was dealing with. In it is a table that displays the apparent numeric precision of floats, ints, and uints derived from shifts bits in shaders until the value wraps to 0 and adding small values to floats until there is no value change. Here's what the table looks like on my Pixel 3. I'm seeing the same values on both Firefox and Chrome for Android. Others have reported a variety of other Pixel devices and others that report the same values:

As you can see the precision of the numbers in structs is half of what it is when using a regular variable.

It was recommended by @gfxprogrammer (Ken Russell) on twitter to share this information here to try to get to the bottom of the behavior. Specifically I'm interested in whether or not this is intended behavior / adhering to the WebGL spec? Is it something that can be fixed? Others have suggested that this maybe an intentional compatibility change by Qualcomm to support some specific apps. More concrete information would be appreciated if it's available.

Thank you!

[kdashg]

It seems like it's dropping to mediump for that struct member. I believe this is a driver bug.

There is language in the spec that precision qualifiers only apply to their scope and within. Struct declarations do kinda look like local scopes, but clearly the intent is that they retain their precision. (FWIW there's no other way to change/adjust a struct or member's precision)

[lexaknyazev]

Maybe related, two more Adreno integer bugs:

• Add uint-int-shift-bug test #3190
• Add precision-side-effects-bug test #3192

[gkjohnson]

Thanks guys -- are there next steps here? Should a Chrome bug be made to inform the browser team? Is there a way to inform Qualcomm so this can maybe be fixed?

[Strepto]

This seems to still be an issue on a lot of android devices. Any progress on this?

[kdashg]

Someone should definitely inform Qualcomm if it's still an issue on new drivers for them.
It might be possible to do scalar decompositions of structs, but that's a pain.
We would benefit from a conformance test for this issue, in case it's different than #3190 and #3192.
Maybe that's why I'm assigned, but I don't remember.

[kenrussell]

If the issue isn't resolved in Qualcomm's drivers, then the most feasible and general workaround would be to start using ANGLE's Vulkan backend to implement WebGL on these devices - it would be a drop-in replacement providing OpenGL ES and WebGL semantics. It'd be very difficult to transform WebGL shaders correctly in all situations to work around this driver bug.

[gkjohnson]

Someone should definitely inform Qualcomm if it's still an issue on new drivers for them.

This is definitely still an issue on Android Pixel 3. I'm not aware of how to report anything like this to Qualcomm.

[Strepto]

Just to add a datapoint. The test webpage link from gkjohnson seems to give accurate values, and displays 10bit floating point mantissam and 16 bit int in fragment shader struct values on an Adreno 660, on an Asus Zenfone 8. Chome 106.0.5249.126, Android 12.