Most of the time, mobile GPU comparisons involve benchmarks such as Antutu, Nenamark 2, etc…, or people may consider which games will be able to run smoothly with a particular device, but we seldom compare image quality, for the simple reason it’s usually more difficult to achieve.
YOUi Labs has just done that, however, by running the shader code below on several hardware platforms, mainly Android tablets, with the most common mobile GPUs, and used the results obtained with a Desktop PC GPU, Nvidia Geforce GT 630M, has a reference.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
precision highp float; uniform vec2 resolution; void main( void ) { float x = ( 1.0 – ( gl_FragCoord.x / resolution.x )); float y = ( gl_FragCoord.y / resolution.y ) * 26.0; float yp = pow( 2.0, floor(y) ); float fade = fract( yp + fract(x) ); if(fract(y) < 0.9) gl_FragColor = vec4( vec3( fade ), 1.0 ); else gl_FragColor = vec4( 0.0 ); } |
Here are the results:
The worst GPUs are Mali-400 MP4 in Exynos 4412 and Geforce ULP in Tegra 3, which can respectively only show 5 and 8 lines before degradation, and the top two GPUs are Qualcomm Adreno 225 in MSM8660A, and Vivante GC4000 in HiSilicon K3V2 processor. Imagination Technologies SGX544 and ARM Mali-T604 also provide decent results, but just not as good as the two aforementioned.
YOUi Labs has also released a free Android app called Shader Effect Test that allows you to evaluate your GPU floating-point accuracy by running visual effects tests on your own device, but for some reasons it does not include the code above.
The company explains that if you plan to run this application on your hardware, this demo will push your GPU and/or drivers to the limits so it may crash, or some shaders may appear off-center or incorrectly positioned. They explain this is normal, at least for some hardware.
I’ve tried it on AMLogic AML8726-MX hardware (Mali-400 MP2), and some of the tests do not look pretty at all, but I can’t draw any conclusion as I haven’t tried with other SoCs.
I’m pretty sure it’s possible to draw smooth edges and properly rounded 3D balls with Mali-400 MP2, but the nature of the tests requires more precision than this GPU can handle.
Jean-Luc started CNX Software in 2010 as a part-time endeavor, before quitting his job as a software engineering manager, and starting to write daily news, and reviews full time later in 2011.
Support CNX Software! Donate via cryptocurrencies, become a Patron on Patreon, or purchase goods on Amazon or Aliexpress
Its look like the Honor 2 was a good deal…
float16 vs float32
I remember float 24 on old ATI
PowerVR tests
http://withimagination.imgtec.com/index.php/powervr/rockchip-releases-rk3168-soc-with-powervr-sgx-graphics-we-go-hands-on-with-image-quality-tests
fp precision isn’t specified in opengl, so this test doesn’t really mean much. I presume even the accuracy of the pow function will be up to the vendor (in opencl they must meed a minimum and document differences, I don’t know if opengl requires the same).
There have been a lot of overly-detailed micro-benchmarks of late which I think are starting to miss the big picture. They should always be taken with a grain of salt.
The reason behind the “””terrible””” performance of the mali-400 is that the mali utgard fragment shader is half-float only, 16-bit floating point. Good enough for rendering an image on a mobile platform, is what the crazy demosceners thought, years before people started talking about Compute and stuff 🙂
Actually… The fragment shader shown lists “precision highp float;”. That simply is not accepted by the mali shader compiler. The author of this must have removed that line when the compiler complained, and then thought nothing of it. Rather bad form. I am sure that his real world use cases (which should be gles2.0 use cases for a fair comparison — another thing he does not point out — he makes no distinction between generations here) are not hampered by the lack of precision on the calculations of the fragment shader.
Mali-400 fragment shader precision is low, but it is deterministic. The real loser here is PVR. That indeed might be overflows and artifacts there.
ARM has started to give an answer to the YOUi Labs tests.
http://blogs.arm.com/multimedia/965-benchmarking-floating-point-precision-in-mobile-gpus/