Dear ARM, in charge of the Mali GPU:

DO NOT REUSE THE SAME DEVICE ID FOR TWO DIFFERENT GPU MODELS.
STOP DOING THAT.

In case you don’t understand what I’m talking about, here’s an example:

• The Mali-G76 MC4 that comes in the Xiaomi Mi 10 has a device ID of 0x72110000
• The Samsung Galaxy Note 10+ identifies itself as Mali-G76 and also has a device ID of 0x72110000, however it is actually Mali-G76 MP12

in 3DMark for Android Wild Life, the MC4 model has a score 1483, the MP12 model has a score of 3394.

I’m going to be straight: THIS IS BULLSHIT.

If NVIDIA couldn’t get away with branding their GeForce 4080 12GB model as a 4080 which was considerably inferior to the 4080 16GB model (and had to be rebranded as GeForce 4070, and their VBIOS reflashed), neither can you.

Why this is important

A good video game experience means that “everything works great out of the box”.

In order to do that, we need to know how fast the phone is.

In other words, query the GPU & CPU model, look up our database and prepare the best settings for that particular model (i.e. low/mid/high settings for low/mid/high tier end phones respectively)

We can’t do that if “Mali-G76” has a performance gap of 2.3x or more between models.

“It’s up to the OEM”

No. It’s not.

Qualcomm doesn’t have this problem. ImgTec doesn’t have this problem. Only Mali has it.

Adreno in terms of speed 630 > 620 > 610 > 605 and this is reflected in their vendor IDs. In fact, adreno device IDs often correspond to their marketing names, which is a plus.

I hate Qualcomm Adrenos for many reasons, but they got this right.

What we need from ARM

For the future

So for the future: Stop doing this. Lay clear, ground rules on how the device IDs are assigned.

You can’t have a >= 1.2x perf gap between models carrying the same device ID and marketing name. Once you cross that threshold it’s a different GPU model.

Yes, I know it’s the same chip with the same capabilities but with more cores. Reflect this on the device id. Reserve N bits for the number of cores if you wish.

In the meantime

So, the problem is out in the wild. It can’t be corrected. As gamedevs, what we need is a thin library on Github that takes a VkPhysicalDeviceProperties and whatever else is necessary to parse the model and returns an enum with the exact model (e.g. ARM_MALI_G76_MP12) and a score with a (rough) relative performance score.

Something like this:

enum ArmGpuArch
{
    ARM_MIDGARD,
    ARM_BIFROST,
    // ...
}
enum ArmMaliModels
{
   ARM_MALI_G76,
   ARM_MALI_G76_MC4,
   ARM_MALI_G76_MP12,
   // ...
};

struct ArmModelInfo
{
    ArmGpuArch arch;
    ArmMaliModels model;
    uint32_t relativeScore;
};

static bool ArmAnalyzeModel(
    const VkPhysicalDeviceProperties &deviceProps,
    ArmModelInfo &outModelInfo );

ArmModelInfo model;
if( ArmAnalyzeModel( deviceProps, model, relativeScore ) )
{
    // could be determined
    if( model.relativeScore == 0u )
    {
        // GPU is ARM, but we can't estimate its performance
    }
    else
    {
        // GPU is ARM and we know its estimated performance
    }
}
else
{
    // Model could not be determined (i.e. library database is too old?)
    // Model is not ARM
    // model and relativeScore are left uninitialized
}

Until ARM doesn’t fix this and/or provide us with means to identify the models, the experience for those with ARM Mali GPUs is going to suck.