Vulkan test failing again

Hi, recently the Vulkan test has been failing for me on Arch Linux.
Maybe the requirements changed but none of the available drivers (amdvlk, vulkan-radeon) seem to work.

Listing only the last 100 lines from a long log.
../mesa-21.1.0/src/amd/vulkan/radv_device.c:6471: FINISHME: Illegal color

../mesa-21.1.0/src/amd/vulkan/radv_meta_clear.c:390: FINISHME: color clears incomplete
[0.245][e] shaderc output:
input:48: error: 'subgroup op' : requires SPIR-V 1.3
input:49: error: 'subgroup op' : requires SPIR-V 1.3
input:50: error: 'subgroup op' : requires SPIR-V 1.3

[0.245][e] shaderc compile status 'error' (3 errors, 0 warnings)
[0.245][e] [  1] #version 450
[0.245][e] [  2] #extension GL_ARB_compute_shader : enable
[0.245][e] [  3] #extension GL_KHR_shader_subgroup_basic : enable 
[0.245][e] [  4] #extension GL_KHR_shader_subgroup_vote : enable 
[0.245][e] [  5] #extension GL_KHR_shader_subgroup_arithmetic : enable 
[0.245][e] [  6] #extension GL_KHR_shader_subgroup_ballot : enable 
[0.245][e] [  7] #extension GL_KHR_shader_subgroup_shuffle : enable 
[0.245][e] [  8] #extension GL_ARB_shader_storage_buffer_object : enable
[0.245][e] [  9] #extension GL_ARB_texture_gather : enable
[0.245][e] [ 10] layout(std430, push_constant) uniform PushC {
[0.245][e] [ 11]     layout(offset=0) vec2 _out_scale_5_0;
[0.245][e] [ 12]     layout(offset=8) vec2 _p0_6_0;
[0.245][e] [ 13]     layout(offset=16) vec2 _p1_7_0;
[0.245][e] [ 14]     layout(offset=24) vec2 _p2_8_0;
[0.245][e] [ 15]     layout(offset=32) vec2 _p3_9_0;
[0.245][e] [ 16] };
[0.245][e] [ 17] layout(binding=0) uniform  sampler2D _src_tex_0_0;
[0.245][e] [ 18] layout(std430, binding=1)  coherent restrict buffer _PeakDetect_2_0 {
[0.245][e] [ 19]     layout(offset=0) vec2 average;
[0.245][e] [ 20]     layout(offset=8) int frame_sum;
[0.245][e] [ 21]     layout(offset=12) int frame_max;
[0.245][e] [ 22]     layout(offset=16) uint counter;
[0.245][e] [ 23] };
[0.245][e] [ 24] layout (local_size_x = 8, local_size_y = 8) in;
[0.245][e] [ 25] #define frag_pos(id) (vec2(id) + vec2(0.5)) 
[0.245][e] [ 26] #define frag_map(id) (_out_scale_5_0 * frag_pos(id))    
[0.245][e] [ 27] #define gl_FragCoord vec4(frag_pos(gl_GlobalInvocationID), 0.0, 1.0) 
[0.245][e] [ 28] #define _tex_coord_1_0_map(id) (mix(mix(_p0_6_0, _p1_7_0, frag_map(id).x),      mix(_p2_8_0, _p3_9_0, frag_map(id).x), frag_map(id).y))
[0.245][e] [ 29] #define _tex_coord_1_0 (_tex_coord_1_0_map(gl_GlobalInvocationID))
[0.245][e] [ 30] 
[0.245][e] [ 31] shared int _wg_sum_3_0;   
[0.245][e] [ 32] shared int _wg_max_4_0;   
[0.245][e] [ 33] vec4 _main_10_0() {
[0.245][e] [ 34] // pl_shader_sample_nearest         
[0.245][e] [ 35] vec4 color = vec4(1.00000000000000000000) * texture(_src_tex_0_0, _tex_coord_1_0); 
[0.245][e] [ 36] // pl_shader_detect_peak 
[0.245][e] [ 37] {                        
[0.245][e] [ 38] vec4 color_orig = color; 
[0.245][e] [ 39] // pl_shader_linearize           
[0.245][e] [ 40] color.rgb = max(color.rgb, 0.0); 
[0.245][e] [ 41] color.rgb = pow(color.rgb, vec3(2.2));
[0.245][e] [ 42] _wg_sum_3_0 = 0; _wg_max_4_0 = 0;   
[0.245][e] [ 43] barrier();        
[0.245][e] [ 44] float sig_max = max(max(color.r, color.g), color.b);  
[0.245][e] [ 45] float sig_log = log(max(sig_max, 0.00100000004749745130));                
[0.245][e] [ 46] int isig_max = int(sig_max * 10000.00000000000000000000);                     
[0.245][e] [ 47] int isig_log = int(sig_log * 400.00000000000000000000);                     
[0.245][e] [ 48] int group_max = subgroupMax(isig_max);    
[0.245][e] [ 49] int group_sum = subgroupAdd(isig_log);    
[0.245][e] [ 50] if (subgroupElect()) {                    
[0.245][e] [ 51]     atomicMax(_wg_max_4_0, group_max);             
[0.245][e] [ 52]     atomicAdd(_wg_sum_3_0, group_sum);             
[0.245][e] [ 53] }                                         
[0.245][e] [ 54] barrier();                                
[0.245][e] [ 55] color = color_orig;   
[0.245][e] [ 56] }                     
[0.245][e] [ 57] // pl_shader_detect_peak                                             
[0.245][e] [ 58] if (gl_LocalInvocationIndex == 0u) {                                 
[0.245][e] [ 59]     int wg_avg = _wg_sum_3_0 / int(gl_WorkGroupSize.x * gl_WorkGroupSize.y);  
[0.245][e] [ 60]     atomicAdd(frame_sum, wg_avg);                                    
[0.245][e] [ 61]     atomicMax(frame_max, _wg_max_4_0);                                        
[0.245][e] [ 62]     memoryBarrierBuffer();                                           
[0.245][e] [ 63] }                                                                    
[0.245][e] [ 64] barrier();                                                           
[0.245][e] [ 65] if (gl_LocalInvocationIndex == 0u) {                                 
[0.245][e] [ 66]     uint num_wg = gl_NumWorkGroups.x * gl_NumWorkGroups.y;           
[0.245][e] [ 67]     if (atomicAdd(counter, 1u) == num_wg - 1u) {                     
[0.245][e] [ 68]         vec2 cur = vec2(float(frame_sum) / float(num_wg), frame_max);
[0.245][e] [ 69]         cur *= vec2(1.0 / 400.00000000000000000000, 1.0 / 10000.00000000000000000000);                             
[0.245][e] [ 70]         cur.x = exp(cur.x);                                          
[0.245][e] [ 71]         if (average.y == 0.0) 
[0.245][e] [ 72]             average = cur;    
[0.245][e] [ 73]         average += 0.00995008368045091629 * (cur - average); 
[0.245][e] [ 74]     float delta = abs(log(cur.x / average.x));               
[0.245][e] [ 75]     average = mix(average, cur, smoothstep(1.26642191410064697265, 2.30258512496948242187, delta));  
[0.245][e] [ 76]         frame_sum = 0;            
[0.245][e] [ 77]         frame_max = 0;            
[0.245][e] [ 78]         counter = 0u;             
[0.245][e] [ 79]         memoryBarrierBuffer();    
[0.245][e] [ 80]     }                             
[0.245][e] [ 81] }                                 
[0.245][e] [ 82] return color;
[0.245][e] [ 83] }
[0.245][e] [ 84] 
[0.245][e] [ 85] void main() {
[0.245][e] [ 86] _main_10_0();
[0.245][e] [ 87] }
[0.245][e] vk_compile_glsl(gpu, tmp, GLSL_SHADER_COMPUTE, params->glsl_shader, &comp): VK_ERROR_INITIALIZATION_FAILED (../src/vulkan/gpu.c:2711)
[0.245][e] Failed creating render pass for dispatch
=== FAILED: 'pl_dispatch_compute(dp, &(struct pl_dispatch_compute_params) { .shader = &sh, .width = fbo->params.w, .height = fbo->params.h, })' at ../src/tests/gpu_tests.h:562
―――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――

12/12 opengl_surfaceless.c         OK              1.69s

Summary of Failures:

11/12 vulkan.c             FAIL            0.31s   exit status 1

This also translates into failing libplacebo tonemapping (through vs-placebo), which I haven't been able to test with plplay because it's also segfaulting on me.

Full log: testlog.txt

Hardware & info:

  • GPU: AMD Navi 5500 XT
  • Kernel Driver: amdgpu 5.12.2
  • OpenGL Driver: Mesa 21.1.0 (OpenGL 4.6)