dEQP-VK.pipeline.cache.misc_tests.merge_cache_test
dEQP-VK.pipeline.cache.misc_tests.cache_header_test
dEQP-VK.pipeline.cache.misc_tests.invalid_size_test
-dEQP-VK.pipeline.render_to_image.1d.54.r8g8b8a8_unorm
-dEQP-VK.pipeline.render_to_image.1d.54.r32_uint
-dEQP-VK.pipeline.render_to_image.1d.54.r16g16_sint
-dEQP-VK.pipeline.render_to_image.1d.54.r32g32b32a32_sfloat
-dEQP-VK.pipeline.render_to_image.1d_array.54_4.r8g8b8a8_unorm
-dEQP-VK.pipeline.render_to_image.1d_array.54_4.r32_uint
-dEQP-VK.pipeline.render_to_image.1d_array.54_4.r16g16_sint
-dEQP-VK.pipeline.render_to_image.1d_array.54_4.r32g32b32a32_sfloat
-dEQP-VK.pipeline.render_to_image.2d.22x64.r8g8b8a8_unorm
-dEQP-VK.pipeline.render_to_image.2d.22x64.r32_uint
-dEQP-VK.pipeline.render_to_image.2d.22x64.r16g16_sint
-dEQP-VK.pipeline.render_to_image.2d.22x64.r32g32b32a32_sfloat
-dEQP-VK.pipeline.render_to_image.2d_array.22x64_4.r8g8b8a8_unorm
-dEQP-VK.pipeline.render_to_image.2d_array.22x64_4.r32_uint
-dEQP-VK.pipeline.render_to_image.2d_array.22x64_4.r16g16_sint
-dEQP-VK.pipeline.render_to_image.2d_array.22x64_4.r32g32b32a32_sfloat
-dEQP-VK.pipeline.render_to_image.3d.22x64x7.r8g8b8a8_unorm
-dEQP-VK.pipeline.render_to_image.3d.22x64x7.r32_uint
-dEQP-VK.pipeline.render_to_image.3d.22x64x7.r16g16_sint
-dEQP-VK.pipeline.render_to_image.3d.22x64x7.r32g32b32a32_sfloat
-dEQP-VK.pipeline.render_to_image.cube.35x35_6.r8g8b8a8_unorm
-dEQP-VK.pipeline.render_to_image.cube.35x35_6.r32_uint
-dEQP-VK.pipeline.render_to_image.cube.35x35_6.r16g16_sint
-dEQP-VK.pipeline.render_to_image.cube.35x35_6.r32g32b32a32_sfloat
-dEQP-VK.pipeline.render_to_image.cube_array.35x35_12.r8g8b8a8_unorm
-dEQP-VK.pipeline.render_to_image.cube_array.35x35_12.r32_uint
-dEQP-VK.pipeline.render_to_image.cube_array.35x35_12.r16g16_sint
-dEQP-VK.pipeline.render_to_image.cube_array.35x35_12.r32g32b32a32_sfloat
+dEQP-VK.pipeline.render_to_image.1d.small.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.1d.small.r32_uint
+dEQP-VK.pipeline.render_to_image.1d.small.r16g16_sint
+dEQP-VK.pipeline.render_to_image.1d.small.r32g32b32a32_sfloat
+dEQP-VK.pipeline.render_to_image.1d.small.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.1d.small.r32_uint_d16_unorm
+dEQP-VK.pipeline.render_to_image.1d.small.r16g16_sint_d16_unorm
+dEQP-VK.pipeline.render_to_image.1d.small.r32g32b32a32_sfloat_d16_unorm
+dEQP-VK.pipeline.render_to_image.1d.small.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.1d.small.r32_uint_s8_uint
+dEQP-VK.pipeline.render_to_image.1d.small.r16g16_sint_s8_uint
+dEQP-VK.pipeline.render_to_image.1d.small.r32g32b32a32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.1d.small.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.1d.small.r32_uint_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.1d.small.r16g16_sint_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.1d.small.r32g32b32a32_sfloat_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.1d.small.r8g8b8a8_unorm_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.1d.small.r32_uint_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.1d.small.r16g16_sint_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.1d.small.r32g32b32a32_sfloat_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.1d.huge.width.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.1d.huge.width.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.1d.huge.width.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.1d.huge.width.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.1d.huge.width.r8g8b8a8_unorm_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.1d_array.small.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.1d_array.small.r32_uint
+dEQP-VK.pipeline.render_to_image.1d_array.small.r16g16_sint
+dEQP-VK.pipeline.render_to_image.1d_array.small.r32g32b32a32_sfloat
+dEQP-VK.pipeline.render_to_image.1d_array.small.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.1d_array.small.r32_uint_d16_unorm
+dEQP-VK.pipeline.render_to_image.1d_array.small.r16g16_sint_d16_unorm
+dEQP-VK.pipeline.render_to_image.1d_array.small.r32g32b32a32_sfloat_d16_unorm
+dEQP-VK.pipeline.render_to_image.1d_array.small.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.1d_array.small.r32_uint_s8_uint
+dEQP-VK.pipeline.render_to_image.1d_array.small.r16g16_sint_s8_uint
+dEQP-VK.pipeline.render_to_image.1d_array.small.r32g32b32a32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.1d_array.small.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.1d_array.small.r32_uint_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.1d_array.small.r16g16_sint_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.1d_array.small.r32g32b32a32_sfloat_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.1d_array.small.r8g8b8a8_unorm_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.1d_array.small.r32_uint_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.1d_array.small.r16g16_sint_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.1d_array.small.r32g32b32a32_sfloat_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.1d_array.huge.width.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.1d_array.huge.width.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.1d_array.huge.width.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.1d_array.huge.width.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.1d_array.huge.width.r8g8b8a8_unorm_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.1d_array.huge.layers.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.1d_array.huge.layers.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.1d_array.huge.layers.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.1d_array.huge.layers.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.1d_array.huge.layers.r8g8b8a8_unorm_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.1d_array.huge.width_layers.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.1d_array.huge.width_layers.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.1d_array.huge.width_layers.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.1d_array.huge.width_layers.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.1d_array.huge.width_layers.r8g8b8a8_unorm_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.2d.small.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.2d.small.r32_uint
+dEQP-VK.pipeline.render_to_image.2d.small.r16g16_sint
+dEQP-VK.pipeline.render_to_image.2d.small.r32g32b32a32_sfloat
+dEQP-VK.pipeline.render_to_image.2d.small.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.2d.small.r32_uint_d16_unorm
+dEQP-VK.pipeline.render_to_image.2d.small.r16g16_sint_d16_unorm
+dEQP-VK.pipeline.render_to_image.2d.small.r32g32b32a32_sfloat_d16_unorm
+dEQP-VK.pipeline.render_to_image.2d.small.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.2d.small.r32_uint_s8_uint
+dEQP-VK.pipeline.render_to_image.2d.small.r16g16_sint_s8_uint
+dEQP-VK.pipeline.render_to_image.2d.small.r32g32b32a32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.2d.small.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.2d.small.r32_uint_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.2d.small.r16g16_sint_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.2d.small.r32g32b32a32_sfloat_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.2d.small.r8g8b8a8_unorm_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.2d.small.r32_uint_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.2d.small.r16g16_sint_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.2d.small.r32g32b32a32_sfloat_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.2d.huge.width.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.2d.huge.width.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.2d.huge.width.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.2d.huge.width.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.2d.huge.width.r8g8b8a8_unorm_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.2d.huge.height.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.2d.huge.height.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.2d.huge.height.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.2d.huge.height.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.2d.huge.height.r8g8b8a8_unorm_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.2d.huge.width_height.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.2d.huge.width_height.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.2d.huge.width_height.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.2d.huge.width_height.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.2d.huge.width_height.r8g8b8a8_unorm_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.small.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.2d_array.small.r32_uint
+dEQP-VK.pipeline.render_to_image.2d_array.small.r16g16_sint
+dEQP-VK.pipeline.render_to_image.2d_array.small.r32g32b32a32_sfloat
+dEQP-VK.pipeline.render_to_image.2d_array.small.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.2d_array.small.r32_uint_d16_unorm
+dEQP-VK.pipeline.render_to_image.2d_array.small.r16g16_sint_d16_unorm
+dEQP-VK.pipeline.render_to_image.2d_array.small.r32g32b32a32_sfloat_d16_unorm
+dEQP-VK.pipeline.render_to_image.2d_array.small.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.small.r32_uint_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.small.r16g16_sint_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.small.r32g32b32a32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.small.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.small.r32_uint_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.small.r16g16_sint_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.small.r32g32b32a32_sfloat_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.small.r8g8b8a8_unorm_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.small.r32_uint_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.small.r16g16_sint_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.small.r32g32b32a32_sfloat_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.huge.width.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.2d_array.huge.width.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.2d_array.huge.width.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.huge.width.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.huge.width.r8g8b8a8_unorm_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.huge.height.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.2d_array.huge.height.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.2d_array.huge.height.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.huge.height.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.huge.height.r8g8b8a8_unorm_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.huge.width_height.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.2d_array.huge.width_height.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.2d_array.huge.width_height.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.huge.width_height.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.huge.width_height.r8g8b8a8_unorm_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.huge.layers.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.2d_array.huge.layers.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.2d_array.huge.layers.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.huge.layers.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.huge.layers.r8g8b8a8_unorm_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.huge.width_layers.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.2d_array.huge.width_layers.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.2d_array.huge.width_layers.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.huge.width_layers.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.huge.width_layers.r8g8b8a8_unorm_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.huge.height_layers.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.2d_array.huge.height_layers.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.2d_array.huge.height_layers.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.huge.height_layers.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.huge.height_layers.r8g8b8a8_unorm_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.huge.width_height_layers.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.2d_array.huge.width_height_layers.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.2d_array.huge.width_height_layers.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.huge.width_height_layers.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.2d_array.huge.width_height_layers.r8g8b8a8_unorm_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.small.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.3d.small.r32_uint
+dEQP-VK.pipeline.render_to_image.3d.small.r16g16_sint
+dEQP-VK.pipeline.render_to_image.3d.small.r32g32b32a32_sfloat
+dEQP-VK.pipeline.render_to_image.3d.small.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.3d.small.r32_uint_d16_unorm
+dEQP-VK.pipeline.render_to_image.3d.small.r16g16_sint_d16_unorm
+dEQP-VK.pipeline.render_to_image.3d.small.r32g32b32a32_sfloat_d16_unorm
+dEQP-VK.pipeline.render_to_image.3d.small.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.small.r32_uint_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.small.r16g16_sint_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.small.r32g32b32a32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.small.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.small.r32_uint_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.small.r16g16_sint_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.small.r32g32b32a32_sfloat_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.small.r8g8b8a8_unorm_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.small.r32_uint_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.small.r16g16_sint_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.small.r32g32b32a32_sfloat_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.huge.width.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.3d.huge.width.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.3d.huge.width.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.huge.width.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.huge.width.r8g8b8a8_unorm_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.huge.height.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.3d.huge.height.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.3d.huge.height.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.huge.height.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.huge.height.r8g8b8a8_unorm_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.huge.width_height.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.3d.huge.width_height.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.3d.huge.width_height.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.huge.width_height.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.huge.width_height.r8g8b8a8_unorm_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.huge.depth.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.3d.huge.depth.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.3d.huge.depth.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.huge.depth.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.huge.depth.r8g8b8a8_unorm_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.huge.width_depth.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.3d.huge.width_depth.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.3d.huge.width_depth.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.huge.width_depth.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.huge.width_depth.r8g8b8a8_unorm_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.huge.height_depth.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.3d.huge.height_depth.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.3d.huge.height_depth.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.huge.height_depth.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.huge.height_depth.r8g8b8a8_unorm_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.huge.width_height_depth.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.3d.huge.width_height_depth.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.3d.huge.width_height_depth.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.huge.width_height_depth.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.3d.huge.width_height_depth.r8g8b8a8_unorm_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.cube.small.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.cube.small.r32_uint
+dEQP-VK.pipeline.render_to_image.cube.small.r16g16_sint
+dEQP-VK.pipeline.render_to_image.cube.small.r32g32b32a32_sfloat
+dEQP-VK.pipeline.render_to_image.cube.small.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.cube.small.r32_uint_d16_unorm
+dEQP-VK.pipeline.render_to_image.cube.small.r16g16_sint_d16_unorm
+dEQP-VK.pipeline.render_to_image.cube.small.r32g32b32a32_sfloat_d16_unorm
+dEQP-VK.pipeline.render_to_image.cube.small.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.cube.small.r32_uint_s8_uint
+dEQP-VK.pipeline.render_to_image.cube.small.r16g16_sint_s8_uint
+dEQP-VK.pipeline.render_to_image.cube.small.r32g32b32a32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.cube.small.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.cube.small.r32_uint_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.cube.small.r16g16_sint_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.cube.small.r32g32b32a32_sfloat_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.cube.small.r8g8b8a8_unorm_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.cube.small.r32_uint_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.cube.small.r16g16_sint_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.cube.small.r32g32b32a32_sfloat_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.cube.huge.width_height.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.cube.huge.width_height.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.cube.huge.width_height.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.cube.huge.width_height.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.cube.huge.width_height.r8g8b8a8_unorm_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.cube_array.small.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.cube_array.small.r32_uint
+dEQP-VK.pipeline.render_to_image.cube_array.small.r16g16_sint
+dEQP-VK.pipeline.render_to_image.cube_array.small.r32g32b32a32_sfloat
+dEQP-VK.pipeline.render_to_image.cube_array.small.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.cube_array.small.r32_uint_d16_unorm
+dEQP-VK.pipeline.render_to_image.cube_array.small.r16g16_sint_d16_unorm
+dEQP-VK.pipeline.render_to_image.cube_array.small.r32g32b32a32_sfloat_d16_unorm
+dEQP-VK.pipeline.render_to_image.cube_array.small.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.cube_array.small.r32_uint_s8_uint
+dEQP-VK.pipeline.render_to_image.cube_array.small.r16g16_sint_s8_uint
+dEQP-VK.pipeline.render_to_image.cube_array.small.r32g32b32a32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.cube_array.small.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.cube_array.small.r32_uint_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.cube_array.small.r16g16_sint_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.cube_array.small.r32g32b32a32_sfloat_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.cube_array.small.r8g8b8a8_unorm_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.cube_array.small.r32_uint_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.cube_array.small.r16g16_sint_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.cube_array.small.r32g32b32a32_sfloat_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.cube_array.huge.width_height.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.cube_array.huge.width_height.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.cube_array.huge.width_height.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.cube_array.huge.width_height.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.cube_array.huge.width_height.r8g8b8a8_unorm_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.cube_array.huge.layers.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.cube_array.huge.layers.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.cube_array.huge.layers.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.cube_array.huge.layers.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.cube_array.huge.layers.r8g8b8a8_unorm_d32_sfloat_s8_uint
+dEQP-VK.pipeline.render_to_image.cube_array.huge.width_height_layers.r8g8b8a8_unorm
+dEQP-VK.pipeline.render_to_image.cube_array.huge.width_height_layers.r8g8b8a8_unorm_d16_unorm
+dEQP-VK.pipeline.render_to_image.cube_array.huge.width_height_layers.r8g8b8a8_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.cube_array.huge.width_height_layers.r8g8b8a8_unorm_d24_unorm_s8_uint
+dEQP-VK.pipeline.render_to_image.cube_array.huge.width_height_layers.r8g8b8a8_unorm_d32_sfloat_s8_uint
dEQP-VK.binding_model.shader_access.primary_cmd_buf.sampler_mutable.no_access.single_descriptor.1d
dEQP-VK.binding_model.shader_access.primary_cmd_buf.sampler_mutable.no_access.single_descriptor.1d_base_mip
dEQP-VK.binding_model.shader_access.primary_cmd_buf.sampler_mutable.no_access.single_descriptor.1d_base_slice
#include <string>
#include <vector>
+#include <set>
namespace vkt
{
using tcu::IVec3;
using tcu::Vec4;
using tcu::UVec4;
+using tcu::IVec2;
using tcu::IVec4;
+using tcu::BVec4;
using std::vector;
typedef SharedPtr<Unique<VkImageView> > SharedPtrVkImageView;
enum Constants
{
- REFERENCE_COLOR_VALUE = 125
+ NUM_CUBE_FACES = 6,
+ REFERENCE_COLOR_VALUE = 125,
+ REFERENCE_STENCIL_VALUE = 42,
+ MAX_SIZE = -1, //!< Should be queried at runtime and replaced with max possible value
+ MAX_VERIFICATION_REGION_SIZE = 32, //!< Limit the checked area to a small size, especially for huge images
+ MAX_VERIFICATION_REGION_DEPTH = 8,
+
+ MASK_W = (1 | 0 | 0 | 0),
+ MASK_W_LAYERS = (1 | 0 | 0 | 8),
+ MASK_WH = (1 | 2 | 0 | 0),
+ MASK_WH_LAYERS = (1 | 2 | 0 | 8),
+ MASK_WHD = (1 | 2 | 4 | 0),
};
+static const float REFERENCE_DEPTH_VALUE = 1.0f;
+
struct CaseDef
{
- VkImageViewType imageType;
- IVec3 renderSize;
- int numLayers;
+ VkImageViewType viewType;
+ IVec4 imageSizeHint; //!< (w, h, d, layers), a component may have a symbolic value MAX_SIZE
VkFormat colorFormat;
+ VkFormat depthStencilFormat; //! A depth/stencil format, or UNDEFINED if not used
};
template<typename T>
return vec.size() * sizeof(vec[0]);
}
+inline bool isCube (const VkImageViewType viewType)
+{
+ return (viewType == VK_IMAGE_VIEW_TYPE_CUBE || viewType == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY);
+}
+
+inline VkDeviceSize product (const IVec4& v)
+{
+ return ((static_cast<VkDeviceSize>(v.x()) * v.y()) * v.z()) * v.w();
+}
+
+// This is very test specific, so be careful if you want to reuse this code.
Move<VkPipeline> makeGraphicsPipeline (const DeviceInterface& vk,
const VkDevice device,
+ const VkPipeline basePipeline, // for derivatives
const VkPipelineLayout pipelineLayout,
const VkRenderPass renderPass,
const VkShaderModule vertexModule,
const VkShaderModule fragmentModule,
- const IVec3 renderSize,
+ const IVec2& renderSize,
const VkPrimitiveTopology topology,
- const deUint32 subpass)
+ const deUint32 subpass,
+ const bool useDepth,
+ const bool useStencil)
{
const VkVertexInputBindingDescription vertexInputBindingDescription =
{
};
const VkStencilOpState stencilOpState = makeStencilOpState(
- VK_STENCIL_OP_KEEP, // stencil fail
- VK_STENCIL_OP_KEEP, // depth & stencil pass
- VK_STENCIL_OP_KEEP, // depth only fail
- VK_COMPARE_OP_ALWAYS, // compare op
- 0u, // compare mask
- 0u, // write mask
- 0u); // reference
+ VK_STENCIL_OP_KEEP, // stencil fail
+ VK_STENCIL_OP_ZERO, // depth & stencil pass
+ VK_STENCIL_OP_KEEP, // depth only fail
+ VK_COMPARE_OP_EQUAL, // compare op
+ ~0u, // compare mask
+ ~0u, // write mask
+ static_cast<deUint32>(REFERENCE_STENCIL_VALUE)); // reference
VkPipelineDepthStencilStateCreateInfo pipelineDepthStencilStateInfo =
{
VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkPipelineDepthStencilStateCreateFlags)0, // VkPipelineDepthStencilStateCreateFlags flags;
- VK_FALSE, // VkBool32 depthTestEnable;
+ useDepth, // VkBool32 depthTestEnable;
VK_FALSE, // VkBool32 depthWriteEnable;
VK_COMPARE_OP_LESS, // VkCompareOp depthCompareOp;
VK_FALSE, // VkBool32 depthBoundsTestEnable;
- VK_FALSE, // VkBool32 stencilTestEnable;
+ useStencil, // VkBool32 stencilTestEnable;
stencilOpState, // VkStencilOpState front;
stencilOpState, // VkStencilOpState back;
0.0f, // float minDepthBounds;
}
};
- const VkGraphicsPipelineCreateInfo graphicsPipelineInfo =
+ const VkPipelineCreateFlags flags = (basePipeline == DE_NULL ? VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT
+ : VK_PIPELINE_CREATE_DERIVATIVE_BIT);
+
+ const VkGraphicsPipelineCreateInfo graphicsPipelineInfo =
{
VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
- (VkPipelineCreateFlags)0, // VkPipelineCreateFlags flags;
+ flags, // VkPipelineCreateFlags flags;
DE_LENGTH_OF_ARRAY(pShaderStages), // deUint32 stageCount;
pShaderStages, // const VkPipelineShaderStageCreateInfo* pStages;
&vertexInputStateInfo, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
pipelineLayout, // VkPipelineLayout layout;
renderPass, // VkRenderPass renderPass;
subpass, // deUint32 subpass;
- DE_NULL, // VkPipeline basePipelineHandle;
- 0, // deInt32 basePipelineIndex;
+ basePipeline, // VkPipeline basePipelineHandle;
+ -1, // deInt32 basePipelineIndex;
};
return createGraphicsPipeline(vk, device, DE_NULL, &graphicsPipelineInfo);
}
-//! Make a render pass with one subpass per color attachment and one attachment per image layer.
+//! Make a render pass with one subpass per color attachment and depth/stencil attachment (if used).
Move<VkRenderPass> makeRenderPass (const DeviceInterface& vk,
const VkDevice device,
const VkFormat colorFormat,
+ const VkFormat depthStencilFormat,
const deUint32 numLayers)
{
const VkAttachmentDescription colorAttachmentDescription =
{
- (VkAttachmentDescriptionFlags)0, // VkAttachmentDescriptionFlags flags;
- colorFormat, // VkFormat format;
- VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
- VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
- VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
- VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
- VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
- VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
- VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout finalLayout;
+ (VkAttachmentDescriptionFlags)0, // VkAttachmentDescriptionFlags flags;
+ colorFormat, // VkFormat format;
+ VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
+ VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
+ VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
+ VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
+ VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
+ VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
+ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout finalLayout;
+ };
+ vector<VkAttachmentDescription> attachmentDescriptions(numLayers, colorAttachmentDescription);
+
+ const VkAttachmentDescription depthStencilAttachmentDescription =
+ {
+ (VkAttachmentDescriptionFlags)0, // VkAttachmentDescriptionFlags flags;
+ depthStencilFormat, // VkFormat format;
+ VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
+ VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
+ VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp storeOp;
+ VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp stencilLoadOp;
+ VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
+ VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
+ VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, // VkImageLayout finalLayout;
};
- const vector<VkAttachmentDescription> attachmentDescriptions(numLayers, colorAttachmentDescription);
+
+ if (depthStencilFormat != VK_FORMAT_UNDEFINED)
+ attachmentDescriptions.insert(attachmentDescriptions.end(), numLayers, depthStencilAttachmentDescription);
// Create a subpass for each attachment (each attachement is a layer of an arrayed image).
- vector<VkAttachmentReference> colorAttachmentReferences(numLayers);
+ vector<VkAttachmentReference> colorAttachmentReferences (numLayers);
+ vector<VkAttachmentReference> depthStencilAttachmentReferences(numLayers);
vector<VkSubpassDescription> subpasses;
+ // Ordering here must match the framebuffer attachments
for (deUint32 i = 0; i < numLayers; ++i)
{
const VkAttachmentReference attachmentRef =
{
- i, // deUint32 attachment;
- VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout;
+ i, // deUint32 attachment;
+ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout;
+ };
+ const VkAttachmentReference depthStencilAttachmentRef =
+ {
+ i + numLayers, // deUint32 attachment;
+ VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL // VkImageLayout layout;
};
- colorAttachmentReferences[i] = attachmentRef;
- const VkSubpassDescription subpassDescription =
+ colorAttachmentReferences[i] = attachmentRef;
+ depthStencilAttachmentReferences[i] = depthStencilAttachmentRef;
+
+ const VkAttachmentReference* pDepthStencilAttachment = (depthStencilFormat != VK_FORMAT_UNDEFINED ? &depthStencilAttachmentReferences[i] : DE_NULL);
+ const VkSubpassDescription subpassDescription =
{
- (VkSubpassDescriptionFlags)0, // VkSubpassDescriptionFlags flags;
- VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint;
- 0u, // deUint32 inputAttachmentCount;
- DE_NULL, // const VkAttachmentReference* pInputAttachments;
- 1u, // deUint32 colorAttachmentCount;
- &colorAttachmentReferences[i], // const VkAttachmentReference* pColorAttachments;
- DE_NULL, // const VkAttachmentReference* pResolveAttachments;
- DE_NULL, // const VkAttachmentReference* pDepthStencilAttachment;
- 0u, // deUint32 preserveAttachmentCount;
- DE_NULL // const deUint32* pPreserveAttachments;
+ (VkSubpassDescriptionFlags)0, // VkSubpassDescriptionFlags flags;
+ VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint;
+ 0u, // deUint32 inputAttachmentCount;
+ DE_NULL, // const VkAttachmentReference* pInputAttachments;
+ 1u, // deUint32 colorAttachmentCount;
+ &colorAttachmentReferences[i], // const VkAttachmentReference* pColorAttachments;
+ DE_NULL, // const VkAttachmentReference* pResolveAttachments;
+ pDepthStencilAttachment, // const VkAttachmentReference* pDepthStencilAttachment;
+ 0u, // deUint32 preserveAttachmentCount;
+ DE_NULL // const deUint32* pPreserveAttachments;
};
subpasses.push_back(subpassDescription);
}
{
switch (viewType)
{
- case VK_IMAGE_VIEW_TYPE_1D:
- case VK_IMAGE_VIEW_TYPE_1D_ARRAY:
- return VK_IMAGE_TYPE_1D;
+ case VK_IMAGE_VIEW_TYPE_1D:
+ case VK_IMAGE_VIEW_TYPE_1D_ARRAY:
+ return VK_IMAGE_TYPE_1D;
+
+ case VK_IMAGE_VIEW_TYPE_2D:
+ case VK_IMAGE_VIEW_TYPE_2D_ARRAY:
+ case VK_IMAGE_VIEW_TYPE_CUBE:
+ case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY:
+ return VK_IMAGE_TYPE_2D;
+
+ case VK_IMAGE_VIEW_TYPE_3D:
+ return VK_IMAGE_TYPE_3D;
+
+ default:
+ DE_ASSERT(0);
+ return VK_IMAGE_TYPE_LAST;
+ }
+}
+
+//! ImageViewType for accessing a single layer/slice of an image
+VkImageViewType getImageViewSliceType (const VkImageViewType viewType)
+{
+ switch (viewType)
+ {
+ case VK_IMAGE_VIEW_TYPE_1D:
+ case VK_IMAGE_VIEW_TYPE_1D_ARRAY:
+ return VK_IMAGE_VIEW_TYPE_1D;
+
+ case VK_IMAGE_VIEW_TYPE_2D:
+ case VK_IMAGE_VIEW_TYPE_2D_ARRAY:
+ case VK_IMAGE_VIEW_TYPE_CUBE:
+ case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY:
+ case VK_IMAGE_VIEW_TYPE_3D:
+ return VK_IMAGE_VIEW_TYPE_2D;
+
+ default:
+ DE_ASSERT(0);
+ return VK_IMAGE_VIEW_TYPE_LAST;
+ }
+}
- case VK_IMAGE_VIEW_TYPE_2D:
- case VK_IMAGE_VIEW_TYPE_2D_ARRAY:
- case VK_IMAGE_VIEW_TYPE_CUBE:
- case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY:
- return VK_IMAGE_TYPE_2D;
+VkImageCreateFlags getImageCreateFlags (const VkImageViewType viewType)
+{
+ VkImageCreateFlags flags = (VkImageCreateFlags)0;
- case VK_IMAGE_VIEW_TYPE_3D:
- return VK_IMAGE_TYPE_3D;
+ if (viewType == VK_IMAGE_VIEW_TYPE_3D) flags |= VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR;
+ if (isCube(viewType)) flags |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
- default:
- DE_ASSERT(0);
- return VK_IMAGE_TYPE_LAST;
- }
+ return flags;
}
void initPrograms (SourceCollections& programCollection, const CaseDef caseDef)
}
}
-tcu::PixelBufferAccess getExpectedData (tcu::TextureLevel& textureLevel, const CaseDef& caseDef, const Vec4* color, const int sizeColor)
+void generateExpectedImage (const tcu::PixelBufferAccess& outputImage, const IVec2& renderSize, const int colorDepthOffset, const Vec4* color, const int numColors)
{
- const bool isInt = isUintFormat(caseDef.colorFormat) || isIntFormat(caseDef.colorFormat);
- const tcu::PixelBufferAccess expectedImage (textureLevel);
+ const tcu::TextureChannelClass channelClass = tcu::getTextureChannelClass(outputImage.getFormat().type);
+ const bool isInt = (channelClass == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER || channelClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER);
+ const VkClearValue clearValue = getClearValue(mapTextureFormat(outputImage.getFormat()));
if (isInt)
- tcu::clear(expectedImage, tcu::IVec4(REFERENCE_COLOR_VALUE));
+ tcu::clear(outputImage, IVec4(clearValue.color.int32));
else
- tcu::clear(expectedImage, tcu::Vec4(1.0));
+ tcu::clear(outputImage, Vec4(clearValue.color.float32));
- for (int z = 0; z < expectedImage.getDepth(); ++z)
+ for (int z = 0; z < outputImage.getDepth(); ++z)
{
- const Vec4& setColor = color[z % sizeColor];
+ const Vec4& setColor = color[(z + colorDepthOffset) % numColors];
const IVec4 setColorInt = (static_cast<float>(REFERENCE_COLOR_VALUE) * setColor).cast<deInt32>();
- for (int y = 0; y < caseDef.renderSize.y(); ++y)
- for (int x = caseDef.renderSize.x()/2; x < caseDef.renderSize.x(); ++x)
+ for (int y = 0; y < renderSize.y(); ++y)
+ for (int x = renderSize.x()/2; x < renderSize.x(); ++x)
{
if (isInt)
- expectedImage.setPixel(setColorInt, x, y, z);
+ outputImage.setPixel(setColorInt, x, y, z);
else
- expectedImage.setPixel(setColor, x, y, z);
+ outputImage.setPixel(setColor, x, y, z);
}
}
- return expectedImage;
}
-tcu::TestStatus test (Context& context, const CaseDef caseDef)
+template <typename T, int Size>
+int findIndexOfMaxComponent (const tcu::Vector<T, Size>& vec)
{
- if (VK_IMAGE_VIEW_TYPE_3D == caseDef.imageType &&
- (!de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_KHR_maintenance1")))
- TCU_THROW(NotSupportedError, "Extension VK_KHR_maintenance1 not supported");
+ int index = 0;
+ T value = vec[0];
+
+ for (int i = 1; i < Size; ++i)
+ {
+ if (vec[i] > value)
+ {
+ index = i;
+ value = vec[i];
+ }
+ }
+
+ return index;
+}
+
+VkDeviceSize getMaxDeviceHeapSize (const InstanceInterface& vki, const VkPhysicalDevice physDevice)
+{
+ const VkPhysicalDeviceMemoryProperties memoryProperties = getPhysicalDeviceMemoryProperties(vki, physDevice);
+ VkDeviceSize memorySize = 0;
+
+ for (deUint32 heapNdx = 0; heapNdx < memoryProperties.memoryHeapCount; ++heapNdx)
+ {
+ if ((memoryProperties.memoryHeaps[heapNdx].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) != 0)
+ memorySize = std::max(memorySize, memoryProperties.memoryHeaps[heapNdx].size);
+ }
+
+ return memorySize;
+}
+
+//! Get a smaller image size. Returns a vector of zeroes, if it can't reduce more.
+IVec4 getReducedImageSize (const CaseDef& caseDef, IVec4 size)
+{
+ const int maxIndex = findIndexOfMaxComponent(size);
+ const int reducedSize = size[maxIndex] >> 1;
+ switch (caseDef.viewType)
+ {
+ case VK_IMAGE_VIEW_TYPE_CUBE:
+ case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY:
+ if (maxIndex < 2)
+ size.x() = size.y() = reducedSize;
+ else if (maxIndex == 3 && reducedSize >= NUM_CUBE_FACES)
+ size.w() = NUM_CUBE_FACES * (reducedSize / NUM_CUBE_FACES); // round down to a multiple of 6
+ else
+ size = IVec4(0);
+ break;
+
+ default:
+ size[maxIndex] = reducedSize;
+ break;
+ }
+
+ if (reducedSize == 0)
+ size = IVec4(0);
+
+ return size;
+}
+
+bool isDepthStencilFormatSupported (const InstanceInterface& vki, const VkPhysicalDevice physDevice, const VkFormat format)
+{
+ const VkFormatProperties properties = getPhysicalDeviceFormatProperties(vki, physDevice, format);
+ return (properties.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) != 0;
+}
+
+IVec4 getMaxImageSize (const VkPhysicalDeviceLimits& limits, const VkImageViewType viewType, const IVec4& sizeHint, const bool useDepthStencil)
+{
+ // If we use a layered D/S together with a 3D image, we have to use the smallest common limit
+ const int maxDepth = (useDepthStencil ? deMin32(static_cast<int>(limits.maxImageArrayLayers), static_cast<int>(limits.maxImageDimension3D))
+ : static_cast<int>(limits.maxImageDimension3D));
+
+ // Images have to respect framebuffer limits and image limits (the framebuffer is not layered in this case)
+ IVec4 size = IVec4(
+ sizeHint.x() != MAX_SIZE ? sizeHint.x() : static_cast<int>(limits.maxFramebufferWidth),
+ sizeHint.y() != MAX_SIZE ? sizeHint.y() : static_cast<int>(limits.maxFramebufferHeight),
+ sizeHint.z() != MAX_SIZE ? sizeHint.z() : maxDepth,
+ sizeHint.w() != MAX_SIZE ? sizeHint.w() : static_cast<int>(limits.maxImageArrayLayers));
+
+ switch (viewType)
+ {
+ case VK_IMAGE_VIEW_TYPE_1D:
+ case VK_IMAGE_VIEW_TYPE_1D_ARRAY:
+ size.x() = deMin32(size.x(), limits.maxImageDimension1D);
+ break;
+
+ case VK_IMAGE_VIEW_TYPE_2D:
+ case VK_IMAGE_VIEW_TYPE_2D_ARRAY:
+ size.x() = deMin32(size.x(), limits.maxImageDimension2D);
+ size.y() = deMin32(size.y(), limits.maxImageDimension2D);
+ break;
+
+ case VK_IMAGE_VIEW_TYPE_3D:
+ size.x() = deMin32(size.x(), limits.maxImageDimension3D);
+ size.y() = deMin32(size.y(), limits.maxImageDimension3D);
+ break;
+
+ case VK_IMAGE_VIEW_TYPE_CUBE:
+ case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY:
+ size.x() = size.y() = deMin32(size.x(), limits.maxImageDimensionCube);
+ size.w() = NUM_CUBE_FACES * (size.w() / NUM_CUBE_FACES); // round down to 6 faces
+ break;
+
+ default:
+ DE_ASSERT(0);
+ return IVec4();
+ }
+
+ return size;
+}
+
+VkImageAspectFlags getFormatAspectFlags (const VkFormat format)
+{
+ if (format == VK_FORMAT_UNDEFINED)
+ return 0;
+
+ const tcu::TextureFormat::ChannelOrder order = mapVkFormat(format).order;
+
+ switch (order)
+ {
+ case tcu::TextureFormat::DS: return VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
+ case tcu::TextureFormat::D: return VK_IMAGE_ASPECT_DEPTH_BIT;
+ case tcu::TextureFormat::S: return VK_IMAGE_ASPECT_STENCIL_BIT;
+ default: return VK_IMAGE_ASPECT_COLOR_BIT;
+ }
+}
+
+//! See testAttachmentSize description
+tcu::TestStatus testWithSizeReduction (Context& context, const CaseDef& caseDef, const int sizeReductionIndex)
+{
const DeviceInterface& vk = context.getDeviceInterface();
+ const InstanceInterface& vki = context.getInstanceInterface();
const VkDevice device = context.getDevice();
+ const VkPhysicalDevice physDevice = context.getPhysicalDevice();
const VkQueue queue = context.getUniversalQueue();
const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
Allocator& allocator = context.getDefaultAllocator();
- Move<VkImage> colorImage;
- MovePtr<Allocation> colorImageAlloc;
const Vec4 color[] =
{
Vec4(0.9f, 0.0f, 0.0f, 1.0f),
Vec4(0.3f, 0.0f, 1.0f, 1.0f),
Vec4(0.1f, 0.0f, 1.0f, 1.0f)
};
+ // The memory might be too small to allocate a largest possible attachment, so try to account for that.
+ const bool useDepthStencil = (caseDef.depthStencilFormat != VK_FORMAT_UNDEFINED);
+ const VkDeviceSize deviceMemoryBudget = getMaxDeviceHeapSize(vki, physDevice) >> 2;
+ IVec4 imageSize = getMaxImageSize(context.getDeviceProperties().limits, caseDef.viewType, caseDef.imageSizeHint, useDepthStencil);
+
+ // Keep reducing the size, if needed
+ for (int i = 0; i < sizeReductionIndex; ++i)
+ {
+ imageSize = getReducedImageSize(caseDef, imageSize);
- const int numLayers = (VK_IMAGE_VIEW_TYPE_3D == caseDef.imageType ? caseDef.renderSize.z() : caseDef.numLayers);
- const VkDeviceSize colorBufferSize = caseDef.renderSize.x() * caseDef.renderSize.y() * caseDef.renderSize.z() * caseDef.numLayers * tcu::getPixelSize(mapVkFormat(caseDef.colorFormat));
+ if (imageSize == IVec4())
+ return tcu::TestStatus::fail("Couldn't create an image with required size");
+ }
+
+ context.getTestContext().getLog()
+ << tcu::TestLog::Message << "Using an image with size (width, height, depth, layers) = " << imageSize << tcu::TestLog::EndMessage;
+
+ // "Slices" is either the depth of a 3D image, or the number of layers of an arrayed image
+ const deInt32 numSlices = (VK_IMAGE_VIEW_TYPE_3D == caseDef.viewType ? imageSize.z() : imageSize.w());
+ const VkDeviceSize colorSize = product(imageSize) * tcu::getPixelSize(mapVkFormat(caseDef.colorFormat));
+ const VkDeviceSize depthStencilSize = (useDepthStencil ? product(imageSize) * tcu::getPixelSize(mapVkFormat(caseDef.depthStencilFormat)) : 0ull);
+
+ if (useDepthStencil && !isDepthStencilFormatSupported(vki, physDevice, caseDef.depthStencilFormat))
+ TCU_THROW(NotSupportedError, "Unsupported depth/stencil format");
+
+ if (colorSize + depthStencilSize > deviceMemoryBudget)
+ throw OutOfMemoryError(VK_ERROR_OUT_OF_DEVICE_MEMORY, "Image size exceeds test's image memory budget");
+
+ // Determine the verification bounds. The checked region will be in the center of the rendered image
+ const IVec4 checkSize = tcu::min(imageSize, IVec4(MAX_VERIFICATION_REGION_SIZE,
+ MAX_VERIFICATION_REGION_SIZE,
+ MAX_VERIFICATION_REGION_DEPTH,
+ MAX_VERIFICATION_REGION_DEPTH));
+ const IVec4 checkOffset = (imageSize - checkSize) / 2;
+
+ // Only make enough space for the check region
+ const VkDeviceSize colorBufferSize = product(checkSize) * tcu::getPixelSize(mapVkFormat(caseDef.colorFormat));
const Unique<VkBuffer> colorBuffer (makeBuffer(vk, device, colorBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT));
const UniquePtr<Allocation> colorBufferAlloc (bindBuffer(vk, device, allocator, *colorBuffer, MemoryRequirement::HostVisible));
- const Unique<VkShaderModule> vertexModule (createShaderModule (vk, device, context.getBinaryCollection().get("vert"), 0u));
- const Unique<VkShaderModule> fragmentModule (createShaderModule (vk, device, context.getBinaryCollection().get("frag"), 0u));
- const Unique<VkRenderPass> renderPass (makeRenderPass (vk, device, caseDef.colorFormat, static_cast<deUint32>(numLayers)));
- const Unique<VkPipelineLayout> pipelineLayout (makePipelineLayout (vk, device));
- vector<SharedPtrVkPipeline> pipeline;
- const Unique<VkCommandPool> cmdPool (createCommandPool (vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex));
- const Unique<VkCommandBuffer> cmdBuffer (makeCommandBuffer(vk, device, *cmdPool));
+ const Unique<VkShaderModule> vertexModule (createShaderModule (vk, device, context.getBinaryCollection().get("vert"), 0u));
+ const Unique<VkShaderModule> fragmentModule (createShaderModule (vk, device, context.getBinaryCollection().get("frag"), 0u));
+ const Unique<VkRenderPass> renderPass (makeRenderPass (vk, device, caseDef.colorFormat, caseDef.depthStencilFormat, static_cast<deUint32>(numSlices)));
+ const Unique<VkPipelineLayout> pipelineLayout (makePipelineLayout (vk, device));
+ vector<SharedPtrVkPipeline> pipelines;
+ Move<VkImage> colorImage;
+ MovePtr<Allocation> colorImageAlloc;
vector<SharedPtrVkImageView> colorAttachments;
- vector<VkImageView> attachmentHandles;
+ Move<VkImage> depthStencilImage;
+ MovePtr<Allocation> depthStencilImageAlloc;
+ vector<SharedPtrVkImageView> depthStencilAttachments;
+ vector<VkImageView> attachmentHandles; // all attachments (color and d/s)
Move<VkBuffer> vertexBuffer;
MovePtr<Allocation> vertexBufferAlloc;
Move<VkFramebuffer> framebuffer;
- //create colorImage
+ // Create a color image
{
- const VkImageViewCreateFlags flags = (VK_IMAGE_VIEW_TYPE_3D == caseDef.imageType ? (VkImageViewCreateFlags)VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR : (VkImageViewCreateFlags)0);
- const VkImageUsageFlags colorImageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
- colorImage = makeImage(vk, device, flags, getImageType(caseDef.imageType), caseDef.colorFormat, caseDef.renderSize, caseDef.numLayers, colorImageUsage);
- colorImageAlloc = bindImage(vk, device, allocator, *colorImage, MemoryRequirement::Any);
+ const VkImageUsageFlags imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
+
+ colorImage = makeImage(vk, device, getImageCreateFlags(caseDef.viewType), getImageType(caseDef.viewType), caseDef.colorFormat,
+ imageSize.swizzle(0, 1, 2), imageSize.w(), imageUsage);
+ colorImageAlloc = bindImage(vk, device, allocator, *colorImage, MemoryRequirement::Any);
}
- //create vertexBuffer
+ // Create a depth/stencil image (always a 2D image, optionally layered)
+ if (useDepthStencil)
{
- const vector<Vertex4RGBA> vertices = genFullQuadVertices(numLayers, vector<Vec4>(color, color + DE_LENGTH_OF_ARRAY(color)));
+ const VkImageUsageFlags imageUsage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+
+ depthStencilImage = makeImage(vk, device, (VkImageCreateFlags)0, VK_IMAGE_TYPE_2D, caseDef.depthStencilFormat,
+ IVec3(imageSize.x(), imageSize.y(), 1), numSlices, imageUsage);
+ depthStencilImageAlloc = bindImage(vk, device, allocator, *depthStencilImage, MemoryRequirement::Any);
+ }
+
+ // Create a vertex buffer
+ {
+ const vector<Vertex4RGBA> vertices = genFullQuadVertices(numSlices, vector<Vec4>(color, color + DE_LENGTH_OF_ARRAY(color)));
const VkDeviceSize vertexBufferSize = sizeInBytes(vertices);
vertexBuffer = makeBuffer(vk, device, vertexBufferSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
flushMappedMemoryRange(vk, device, vertexBufferAlloc->getMemory(), vertexBufferAlloc->getOffset(), vertexBufferSize);
}
- //create attachmentHandles and pipelines
- for (int layerNdx = 0; layerNdx < numLayers; ++layerNdx)
+ // For each image layer or slice (3D), create an attachment and a pipeline
{
- const VkImageViewType imageType = (VK_IMAGE_VIEW_TYPE_3D == caseDef.imageType ? VK_IMAGE_VIEW_TYPE_2D_ARRAY :
- (VK_IMAGE_VIEW_TYPE_CUBE == caseDef.imageType || VK_IMAGE_VIEW_TYPE_CUBE_ARRAY == caseDef.imageType ? VK_IMAGE_VIEW_TYPE_2D :
- caseDef.imageType));
+ const VkImageAspectFlags depthStencilAspect = getFormatAspectFlags(caseDef.depthStencilFormat);
+ const bool useDepth = (depthStencilAspect & VK_IMAGE_ASPECT_DEPTH_BIT) != 0;
+ const bool useStencil = (depthStencilAspect & VK_IMAGE_ASPECT_STENCIL_BIT) != 0;
+ VkPipeline basePipeline = DE_NULL;
- colorAttachments.push_back(makeSharedPtr(makeImageView(vk, device, *colorImage, imageType, caseDef.colorFormat, makeColorSubresourceRange(layerNdx, 1))));
- attachmentHandles.push_back(**colorAttachments.back());
+ // Color attachments are first in the framebuffer
+ for (int subpassNdx = 0; subpassNdx < numSlices; ++subpassNdx)
+ {
+ colorAttachments.push_back(makeSharedPtr(
+ makeImageView(vk, device, *colorImage, getImageViewSliceType(caseDef.viewType), caseDef.colorFormat, makeColorSubresourceRange(subpassNdx, 1))));
+ attachmentHandles.push_back(**colorAttachments.back());
- pipeline.push_back(makeSharedPtr(makeGraphicsPipeline(vk, device, *pipelineLayout, *renderPass, *vertexModule, *fragmentModule,
- caseDef.renderSize, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, static_cast<deUint32>(layerNdx))));
- }
+ // We also have to create pipelines for each subpass
+ pipelines.push_back(makeSharedPtr(makeGraphicsPipeline(
+ vk, device, basePipeline, *pipelineLayout, *renderPass, *vertexModule, *fragmentModule, imageSize.swizzle(0, 1), VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
+ static_cast<deUint32>(subpassNdx), useDepth, useStencil)));
- framebuffer = makeFramebuffer(vk, device, *renderPass, numLayers, &attachmentHandles[0], static_cast<deUint32>(caseDef.renderSize.x()), static_cast<deUint32>(caseDef.renderSize.y()));
+ basePipeline = **pipelines.front();
+ }
- beginCommandBuffer(vk, *cmdBuffer);
- {
- const vector<VkClearValue> clearValues (numLayers, getClearValue(caseDef.colorFormat));
- const VkRect2D renderArea =
+ // Then D/S attachments, if any
+ if (useDepthStencil)
+ for (int subpassNdx = 0; subpassNdx < numSlices; ++subpassNdx)
{
- makeOffset2D(0, 0),
- makeExtent2D(caseDef.renderSize.x(), caseDef.renderSize.y()),
- };
- const VkRenderPassBeginInfo renderPassBeginInfo =
- {
- VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- *renderPass, // VkRenderPass renderPass;
- *framebuffer, // VkFramebuffer framebuffer;
- renderArea, // VkRect2D renderArea;
- static_cast<deUint32>(clearValues.size()), // uint32_t clearValueCount;
- &clearValues[0], // const VkClearValue* pClearValues;
- };
- const VkDeviceSize vertexBufferOffset = 0ull;
-
- vk.cmdBeginRenderPass(*cmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
- vk.cmdBindVertexBuffers(*cmdBuffer, 0u, 1u, &vertexBuffer.get(), &vertexBufferOffset);
+ depthStencilAttachments.push_back(makeSharedPtr(
+ makeImageView(vk, device, *depthStencilImage, VK_IMAGE_VIEW_TYPE_2D, caseDef.depthStencilFormat, makeImageSubresourceRange(depthStencilAspect, 0u, 1u, subpassNdx, 1u))));
+ attachmentHandles.push_back(**depthStencilAttachments.back());
+ }
}
- //cmdDraw
- for (deUint32 layerNdx = 0; layerNdx < static_cast<deUint32>(numLayers); ++layerNdx)
+ framebuffer = makeFramebuffer(vk, device, *renderPass, static_cast<deUint32>(attachmentHandles.size()), &attachmentHandles[0], static_cast<deUint32>(imageSize.x()), static_cast<deUint32>(imageSize.y()));
+
{
- if (layerNdx != 0)
- vk.cmdNextSubpass(*cmdBuffer, VK_SUBPASS_CONTENTS_INLINE);
+ const Unique<VkCommandPool> cmdPool (createCommandPool (vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex));
+ const Unique<VkCommandBuffer> cmdBuffer (makeCommandBuffer(vk, device, *cmdPool));
- vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, **pipeline[layerNdx]);
- vk.cmdDraw(*cmdBuffer, 4u, 1u, layerNdx*4u, 0u);
- }
+ beginCommandBuffer(vk, *cmdBuffer);
+ {
+ vector<VkClearValue> clearValues (numSlices, getClearValue(caseDef.colorFormat));
- vk.cmdEndRenderPass(*cmdBuffer);
+ if (useDepthStencil)
+ clearValues.insert(clearValues.end(), numSlices, makeClearValueDepthStencil(REFERENCE_DEPTH_VALUE, REFERENCE_STENCIL_VALUE));
- // copy colorImage -> host visible colorBuffer
- {
- const VkImageMemoryBarrier imageBarriers[] =
- {
+ const VkRect2D renderArea =
{
- VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags outputMask;
- VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags inputMask;
- VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout oldLayout;
- VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
- VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
- VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
- *colorImage, // VkImage image;
- makeColorSubresourceRange(0, caseDef.numLayers) // VkImageSubresourceRange subresourceRange;
- }
- };
-
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u,
- 0u, DE_NULL, 0u, DE_NULL, DE_LENGTH_OF_ARRAY(imageBarriers), imageBarriers);
+ makeOffset2D(0, 0),
+ makeExtent2D(imageSize.x(), imageSize.y()),
+ };
+ const VkRenderPassBeginInfo renderPassBeginInfo =
+ {
+ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ *renderPass, // VkRenderPass renderPass;
+ *framebuffer, // VkFramebuffer framebuffer;
+ renderArea, // VkRect2D renderArea;
+ static_cast<deUint32>(clearValues.size()), // uint32_t clearValueCount;
+ &clearValues[0], // const VkClearValue* pClearValues;
+ };
+ const VkDeviceSize vertexBufferOffset = 0ull;
+
+ vk.cmdBeginRenderPass(*cmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
+ vk.cmdBindVertexBuffers(*cmdBuffer, 0u, 1u, &vertexBuffer.get(), &vertexBufferOffset);
+ }
- const VkBufferImageCopy region =
+ // Draw
+ for (deUint32 subpassNdx = 0; subpassNdx < static_cast<deUint32>(numSlices); ++subpassNdx)
{
- 0ull, // VkDeviceSize bufferOffset;
- 0u, // uint32_t bufferRowLength;
- 0u, // uint32_t bufferImageHeight;
- makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, caseDef.numLayers), // VkImageSubresourceLayers imageSubresource;
- makeOffset3D(0, 0, 0), // VkOffset3D imageOffset;
- makeExtent3D(caseDef.renderSize), // VkExtent3D imageExtent;
- };
+ if (subpassNdx != 0)
+ vk.cmdNextSubpass(*cmdBuffer, VK_SUBPASS_CONTENTS_INLINE);
- vk.cmdCopyImageToBuffer(*cmdBuffer, *colorImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *colorBuffer, 1u, ®ion);
+ vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, **pipelines[subpassNdx]);
+ vk.cmdDraw(*cmdBuffer, 4u, 1u, subpassNdx*4u, 0u);
+ }
+
+ vk.cmdEndRenderPass(*cmdBuffer);
- const VkBufferMemoryBarrier bufferBarriers[] =
+ // Copy colorImage -> host visible colorBuffer
{
+ const VkImageMemoryBarrier imageBarriers[] =
{
- VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
- VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
- VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex;
- VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex;
- *colorBuffer, // VkBuffer buffer;
- 0ull, // VkDeviceSize offset;
- VK_WHOLE_SIZE, // VkDeviceSize size;
- },
- };
+ {
+ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags outputMask;
+ VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags inputMask;
+ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout oldLayout;
+ VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
+ VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
+ VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
+ *colorImage, // VkImage image;
+ makeColorSubresourceRange(0, imageSize.w()) // VkImageSubresourceRange subresourceRange;
+ }
+ };
+
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u,
+ 0u, DE_NULL, 0u, DE_NULL, DE_LENGTH_OF_ARRAY(imageBarriers), imageBarriers);
+
+ // Copy the checked region rather than the whole image
+ const VkImageSubresourceLayers subresource =
+ {
+ VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
+ 0u, // uint32_t mipLevel;
+ static_cast<deUint32>(checkOffset.w()), // uint32_t baseArrayLayer;
+ static_cast<deUint32>(checkSize.w()), // uint32_t layerCount;
+ };
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u,
- 0u, DE_NULL, DE_LENGTH_OF_ARRAY(bufferBarriers), bufferBarriers, 0u, DE_NULL);
- }
+ const VkBufferImageCopy region =
+ {
+ 0ull, // VkDeviceSize bufferOffset;
+ 0u, // uint32_t bufferRowLength;
+ 0u, // uint32_t bufferImageHeight;
+ subresource, // VkImageSubresourceLayers imageSubresource;
+ makeOffset3D(checkOffset.x(), checkOffset.y(), checkOffset.z()), // VkOffset3D imageOffset;
+ makeExtent3D(checkSize.swizzle(0, 1, 2)), // VkExtent3D imageExtent;
+ };
- VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
- submitCommandsAndWait(vk, device, queue, *cmdBuffer);
+ vk.cmdCopyImageToBuffer(*cmdBuffer, *colorImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *colorBuffer, 1u, ®ion);
+
+ const VkBufferMemoryBarrier bufferBarriers[] =
+ {
+ {
+ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
+ VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
+ VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex;
+ VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex;
+ *colorBuffer, // VkBuffer buffer;
+ 0ull, // VkDeviceSize offset;
+ VK_WHOLE_SIZE, // VkDeviceSize size;
+ },
+ };
+
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u,
+ 0u, DE_NULL, DE_LENGTH_OF_ARRAY(bufferBarriers), bufferBarriers, 0u, DE_NULL);
+ }
+
+ VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
+ submitCommandsAndWait(vk, device, queue, *cmdBuffer);
+ }
// Verify results
{
invalidateMappedMemoryRange(vk, device, colorBufferAlloc->getMemory(), colorBufferAlloc->getOffset(), VK_WHOLE_SIZE);
const tcu::TextureFormat format = mapVkFormat(caseDef.colorFormat);
- const int depth = deMax32(caseDef.renderSize.z(), caseDef.numLayers);
- tcu::TextureLevel textureLevel (format, caseDef.renderSize.x(), caseDef.renderSize.y(), depth);
- const tcu::PixelBufferAccess expectedImage = getExpectedData (textureLevel, caseDef, color, DE_LENGTH_OF_ARRAY(color));
- const tcu::ConstPixelBufferAccess resultImage (format, caseDef.renderSize.x(), caseDef.renderSize.y(), depth, colorBufferAlloc->getHostPtr());
+ const int checkDepth = deMax32(checkSize.z(), checkSize.w());
+ const int depthOffset = deMax32(checkOffset.z(), checkOffset.w());
+ const tcu::ConstPixelBufferAccess resultImage (format, checkSize.x(), checkSize.y(), checkDepth, colorBufferAlloc->getHostPtr());
+ tcu::TextureLevel textureLevel (format, checkSize.x(), checkSize.y(), checkDepth);
+ const tcu::PixelBufferAccess expectedImage = textureLevel.getAccess();
+ bool ok = false;
+
+ generateExpectedImage(expectedImage, checkSize.swizzle(0, 1), depthOffset, color, DE_LENGTH_OF_ARRAY(color));
+
+ if (isFloatFormat(caseDef.colorFormat))
+ ok = tcu::floatThresholdCompare(context.getTestContext().getLog(), "Image Comparison", "", expectedImage, resultImage, tcu::Vec4(0.01f), tcu::COMPARE_LOG_RESULT);
+ else
+ ok = tcu::intThresholdCompare(context.getTestContext().getLog(), "Image Comparison", "", expectedImage, resultImage, tcu::UVec4(2), tcu::COMPARE_LOG_RESULT);
- if (!tcu::intThresholdCompare(context.getTestContext().getLog(), "Image Comparison", "", expectedImage, resultImage, tcu::UVec4(2), tcu::COMPARE_LOG_RESULT))
- return tcu::TestStatus::fail("Fail");
+ return ok ? tcu::TestStatus::pass("Pass") : tcu::TestStatus::fail("Fail");
}
- return tcu::TestStatus::pass("Pass");
}
-std::string getSizeString (const IVec3& size, const int numLayer)
+//! A test that can exercise very big color and depth/stencil attachment sizes.
+//! If the total memory consumed by images is too large, or if the implementation returns OUT_OF_MEMORY error somewhere,
+//! the test can be retried with a next increment of size reduction index, making the attachments smaller.
+tcu::TestStatus testAttachmentSize (Context& context, const CaseDef caseDef)
+{
+ if (caseDef.viewType == VK_IMAGE_VIEW_TYPE_3D &&
+ !de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_KHR_maintenance1"))
+ TCU_THROW(NotSupportedError, "Extension VK_KHR_maintenance1 not supported");
+
+ if (caseDef.viewType == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY && !context.getDeviceFeatures().imageCubeArray)
+ TCU_THROW(NotSupportedError, "Missing feature: imageCubeArray");
+
+ int sizeReductionIndex = 0;
+
+ for (;;)
+ {
+ try
+ {
+ return testWithSizeReduction(context, caseDef, sizeReductionIndex);
+ }
+ catch (OutOfMemoryError& ex)
+ {
+ context.getTestContext().getLog()
+ << tcu::TestLog::Message << "-- OutOfMemoryError: " << ex.getMessage() << tcu::TestLog::EndMessage;
+
+ ++sizeReductionIndex;
+ }
+ }
+ // Never reached
+}
+
+std::string getSizeDescription (const IVec4& size)
{
std::ostringstream str;
- str << size.x();
- if (size.y() > 1) str << "x" << size.y();
- if (size.z() > 1) str << "x" << size.z();
- if (numLayer > 1) str << "_" << numLayer;
+
+ const char* const description[4] =
+ {
+ "width", "height", "depth", "layers"
+ };
+
+ int numMaxComponents = 0;
+
+ for (int i = 0; i < 4; ++i)
+ {
+ if (size[i] == MAX_SIZE)
+ {
+ if (numMaxComponents > 0)
+ str << "_";
+
+ str << description[i];
+ ++numMaxComponents;
+ }
+ }
+
+ if (numMaxComponents == 0)
+ str << "small";
return str.str();
}
-std::string getFormatString (const VkFormat format)
+inline std::string getFormatString (const VkFormat format)
{
std::string name(getFormatName(format));
return de::toLower(name.substr(10));
}
+std::string getFormatString (const VkFormat colorFormat, const VkFormat depthStencilFormat)
+{
+ std::ostringstream str;
+ str << getFormatString(colorFormat);
+ if (depthStencilFormat != VK_FORMAT_UNDEFINED)
+ str << "_" << getFormatString(depthStencilFormat);
+ return str.str();
+}
+
std::string getShortImageViewTypeName (const VkImageViewType imageViewType)
{
std::string s(getImageViewTypeName(imageViewType));
return de::toLower(s.substr(19));
}
-CaseDef caseDefWithFormat (CaseDef caseDef, const VkFormat format)
+inline BVec4 bvecFromMask (deUint32 mask)
+{
+ return BVec4((mask >> 0) & 1,
+ (mask >> 1) & 1,
+ (mask >> 2) & 1,
+ (mask >> 3) & 1);
+}
+
+std::vector<IVec4> genSizeCombinations (const IVec4& baselineSize, const deUint32 sizeMask, const VkImageViewType imageViewType)
{
- caseDef.colorFormat = format;
- return caseDef;
+ std::vector<IVec4> sizes;
+ std::set<deUint32> masks;
+
+ for (deUint32 i = 0; i < (1u << 4); ++i)
+ {
+ // Cube images have square faces
+ if (isCube(imageViewType) && ((i & MASK_WH) != 0))
+ i |= MASK_WH;
+
+ masks.insert(i & sizeMask);
+ }
+
+ for (std::set<deUint32>::const_iterator it = masks.begin(); it != masks.end(); ++it)
+ sizes.push_back(tcu::select(IVec4(MAX_SIZE), baselineSize, bvecFromMask(*it)));
+
+ return sizes;
}
void addTestCasesWithFunctions (tcu::TestCaseGroup* group)
{
- const CaseDef caseDef[] =
+ const struct
{
- { VK_IMAGE_VIEW_TYPE_1D, IVec3(54, 1, 1), 1, VK_FORMAT_UNDEFINED},
- { VK_IMAGE_VIEW_TYPE_1D_ARRAY, IVec3(54, 1, 1), 4, VK_FORMAT_UNDEFINED},
- { VK_IMAGE_VIEW_TYPE_2D, IVec3(22, 64, 1), 1, VK_FORMAT_UNDEFINED},
- { VK_IMAGE_VIEW_TYPE_2D_ARRAY, IVec3(22, 64, 1), 4, VK_FORMAT_UNDEFINED},
- { VK_IMAGE_VIEW_TYPE_3D, IVec3(22, 64, 7), 1, VK_FORMAT_UNDEFINED},
- { VK_IMAGE_VIEW_TYPE_CUBE, IVec3(35, 35, 1), 6, VK_FORMAT_UNDEFINED},
- { VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, IVec3(35, 35, 1), 2*6, VK_FORMAT_UNDEFINED},
+ VkImageViewType viewType;
+ IVec4 baselineSize; //!< image size: (dimX, dimY, dimZ, arraySize)
+ deUint32 sizeMask; //!< if a dimension is masked, generate a huge size case for it
+ } testCase[] =
+ {
+ { VK_IMAGE_VIEW_TYPE_1D, IVec4(54, 1, 1, 1), MASK_W },
+ { VK_IMAGE_VIEW_TYPE_1D_ARRAY, IVec4(54, 1, 1, 4), MASK_W_LAYERS },
+ { VK_IMAGE_VIEW_TYPE_2D, IVec4(44, 23, 1, 1), MASK_WH },
+ { VK_IMAGE_VIEW_TYPE_2D_ARRAY, IVec4(44, 23, 1, 4), MASK_WH_LAYERS },
+ { VK_IMAGE_VIEW_TYPE_3D, IVec4(22, 31, 7, 1), MASK_WHD },
+ { VK_IMAGE_VIEW_TYPE_CUBE, IVec4(35, 35, 1, 6), MASK_WH },
+ { VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, IVec4(35, 35, 1, 2*6), MASK_WH_LAYERS },
};
const VkFormat format[] =
VK_FORMAT_R32G32B32A32_SFLOAT,
};
- for (int sizeNdx = 0; sizeNdx < DE_LENGTH_OF_ARRAY(caseDef); ++sizeNdx)
+ const VkFormat depthStencilFormat[] =
+ {
+ VK_FORMAT_UNDEFINED, // don't use a depth/stencil attachment
+ VK_FORMAT_D16_UNORM,
+ VK_FORMAT_S8_UINT,
+ VK_FORMAT_D24_UNORM_S8_UINT, // one of the following mixed formats must be supported
+ VK_FORMAT_D32_SFLOAT_S8_UINT,
+ };
+
+ // Generate attachment size cases for all render targets
+ for (int caseNdx = 0; caseNdx < DE_LENGTH_OF_ARRAY(testCase); ++caseNdx)
{
- MovePtr<tcu::TestCaseGroup> imageGroup(new tcu::TestCaseGroup(group->getTestContext(), getShortImageViewTypeName(caseDef[sizeNdx].imageType).c_str(), ""));
+ MovePtr<tcu::TestCaseGroup> imageGroup(new tcu::TestCaseGroup(group->getTestContext(), getShortImageViewTypeName(testCase[caseNdx].viewType).c_str(), ""));
{
- MovePtr<tcu::TestCaseGroup> sizeGroup(new tcu::TestCaseGroup(group->getTestContext(), getSizeString(caseDef[sizeNdx].renderSize, caseDef[sizeNdx].numLayers).c_str(), ""));
+ const std::vector<IVec4> sizes = genSizeCombinations(testCase[caseNdx].baselineSize, testCase[caseNdx].sizeMask, testCase[caseNdx].viewType);
+
+ MovePtr<tcu::TestCaseGroup> smallGroup(new tcu::TestCaseGroup(group->getTestContext(), "small", ""));
+ MovePtr<tcu::TestCaseGroup> hugeGroup (new tcu::TestCaseGroup(group->getTestContext(), "huge", ""));
- for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(format); ++formatNdx)
- addFunctionCaseWithPrograms(sizeGroup.get(), getFormatString(format[formatNdx]).c_str(), "", initPrograms, test, caseDefWithFormat(caseDef[sizeNdx], format[formatNdx]));
+ imageGroup->addChild(smallGroup.get());
+ imageGroup->addChild(hugeGroup.get());
- imageGroup->addChild(sizeGroup.release());
+ for (std::vector<IVec4>::const_iterator sizeIter = sizes.begin(); sizeIter != sizes.end(); ++sizeIter)
+ {
+ // The first size is the baseline size, put it in a dedicated group
+ if (sizeIter == sizes.begin())
+ {
+ for (int dsFormatNdx = 0; dsFormatNdx < DE_LENGTH_OF_ARRAY(depthStencilFormat); ++dsFormatNdx)
+ for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(format); ++formatNdx)
+ {
+ const CaseDef caseDef =
+ {
+ testCase[caseNdx].viewType, // VkImageViewType imageType;
+ *sizeIter, // IVec4 imageSizeHint;
+ format[formatNdx], // VkFormat colorFormat;
+ depthStencilFormat[dsFormatNdx], // VkFormat depthStencilFormat;
+ };
+ addFunctionCaseWithPrograms(smallGroup.get(), getFormatString(format[formatNdx], depthStencilFormat[dsFormatNdx]), "", initPrograms, testAttachmentSize, caseDef);
+ }
+ }
+ else // All huge cases go into a separate group
+ {
+ MovePtr<tcu::TestCaseGroup> sizeGroup (new tcu::TestCaseGroup(group->getTestContext(), getSizeDescription(*sizeIter).c_str(), ""));
+ const VkFormat colorFormat = VK_FORMAT_R8G8B8A8_UNORM;
+
+ // Use the same color format for all cases, to reduce the number of permutations
+ for (int dsFormatNdx = 0; dsFormatNdx < DE_LENGTH_OF_ARRAY(depthStencilFormat); ++dsFormatNdx)
+ {
+ const CaseDef caseDef =
+ {
+ testCase[caseNdx].viewType, // VkImageViewType viewType;
+ *sizeIter, // IVec4 imageSizeHint;
+ colorFormat, // VkFormat colorFormat;
+ depthStencilFormat[dsFormatNdx], // VkFormat depthStencilFormat;
+ };
+ addFunctionCaseWithPrograms(sizeGroup.get(), getFormatString(colorFormat, depthStencilFormat[dsFormatNdx]), "", initPrograms, testAttachmentSize, caseDef);
+ }
+ hugeGroup->addChild(sizeGroup.release());
+ }
+ }
+ smallGroup.release();
+ hugeGroup.release();
}
group->addChild(imageGroup.release());
}
projects / platform / upstream / VK-GL-CTS.git / commitdiff