The Vulkan 1.2 graphical standard has been released.

The Khronos Consortium, which develops graphics standards,
announced specification Vulkan 1.2, defining the API for accessing the graphical and computational capabilities of GPUs. The new specification incorporates corrections made over the past two years and extension. Drivers supporting the new version of Vulkan are already was released from Intel, AMD, ARM, Imagination Technologies, and NVIDIA. The support for Vulkan 1.2 in Mesa is offered for drivers of RADV (AMD cards) and ANV (Intel). Vulkan 1.2 support is also implemented in the debugger RenderDoc 1.6, LunarG Vulkan SDK , and the set of examples Vulkan-Samples.

Key innovations:

• The implementation of the shader programming language HLSL , developed by Microsoft for DirectX, has reached readiness for widespread adoption. Support for HLSL in Vulkan allows the use of the same HLSL shaders in applications based on Vulkan and DirectX, as well as simplifies the translation from HLSL to SPIR-V. It is recommended to use the standard compilerDXC
  , which was opened by Microsoft in 2017 and is based on LLVM technology. Vulkan support is implemented through a separate backend that allows translating HLSL into the intermediate representation of shaders SPIR-V. This implementation covers not only all the built-in capabilities ofHLSL, including mathematical types, control flows, functions, sets, resource types, namespaces, Shader Model 6.2, structures, and methods, but also allows the use of Vulkan-specific extensions, such as VKRay from NVIDIA. Using HLSL on top of Vulkan has enabled the functioning of games such as Destiny 2, Red Dead Redemption II, Assassin’s Creed Odyssey, and Tomb Raider.
  The specification of
  
• SPIR-V 1.5 , defining a universal intermediate representation of shaders for all platforms that can be applied for both graphics and parallel computing.SPIR-V implies separating the compilation phase of shaders into an intermediate representation, allowing the creation of frontends for various high-level languages. Based on different high-level implementations, a unified intermediate code is generated, which can be used by OpenGL, Vulkan, and OpenCL drivers without utilizing a built-in shader compiler.
  The core API of Vulkan includes 23 extensions that enhance performance, improve rendering quality, and simplify development. Among the added extensions are:
  
• Timeline semaphores
  • Chronological semaphores (Timeline semaphore), unifying synchronizations with the host and device queues (allowing a single primitive for bidirectional synchronization between the device and host, without needing separate primitives VkFence and VkSemaphore). The new semaphores are represented by a monotonically increasing 64-bit value, which can be tracked and updated across multiple threads.
    
  • Support for using numeric types with reduced precision in shaders;
  • HLSL-compatible memory layout variant;
  • Bindless resources, removing the limitation on the number of resources available to shaders by utilizing a shared virtual address space of system memory and GPU memory;
  • Formal memory model, defining how concurrently executing threads can access shared data and synchronization operations;
  • Descriptor indexing for reusing layout descriptors across multiple shaders;
  • Buffer references.

  Full list of added extensions:

  • VK_KHR_8bit_storage
  • VK_KHR_buffer_device_address
  • VK_KHR_create_renderpass2
  • VK_KHR_depth_stencil_resolve
  • VK_KHR_draw_indirect_count
  • VK_KHR_driver_properties
  • VK_KHR_image_format_list
  • VK_KHR_imageless_framebuffer
  • VK_KHR_sampler_mirror_clamp_to_edge
  • VK_KHR_separate_depth_stencil_layouts
  • VK_KHR_shader_atomic_int64
  • VK_KHR_shader_float16_int8
  • VK_KHR_shader_float_controls
  • VK_KHR_shader_subgroup_extended_types
  • VK_KHR_spirv_1_4
  • VK_KHR_timeline_semaphore
  • VK_KHR_uniform_buffer_standard_layout
  • VK_KHR_vulkan_memory_model
  • VK_EXT_descriptor_indexing
  • VK_EXT_host_query_reset
  • VK_EXT_sampler_filter_minmax
  • VK_EXT_scalar_block_layout
  • VK_EXT_separate_stencil_usage
  • VK_EXT_shader_viewport_index_layer
• Added more than 50 new structures and 13 functions;
• Condensed specification versions are prepared for typical target platforms, simplifying work on platforms that do not yet support all extensions, and allowing for operation without selective activation of basic Vulkan API features.
• Work has continued on the portability project with other graphics APIs. For example, in Vulkan, extensions are proposed to translate OpenGL (Zink), OpenCL (clspv, clvk), OpenGL ES (GLOVE, Angle) and DirectX (DXVK, vkd3d) via the Vulkan API, as well as the reverse, to enable Vulkan to operate on platforms without native support (gfx-rs and Ashes to run on top of OpenGL and DirectX, MoltenVK and gfx-rs for running on top of Metal).
  To improve compatibility with DirectX and HLSL, extensions have been added
  VK_KHR_host_query_reset, VK_KHR_uniform_buffer_standard_layout, VK_EXT_scalar_block_layout, VK_KHR_separate_stencil_usage, VK_KHR_separate_depth_stencil_layouts, and specific HLSL capabilities have been implemented in SPIR-V.

Future plans include the development of extensions for machine learning, ray tracing, video encoding and decoding, support for VRS (variable-rate shading), and Mesh shaders.

Recall that the Vulkan API is notable features a radical simplification of drivers by offloading GPU command generation to the application side, the possibility of connecting debugging layers, unifying the API across various platforms, and applying precompiled intermediate code representation for execution on the GPU. To ensure high performance and predictability, Vulkan provides applications with the means to directly manage GPU operations and inherent support for multi-threaded command processing, which minimizes the overhead introduced by the driver, while the capabilities implemented on the driver side are significantly simplified and become more predictable. For example, operations like memory management and error handling, implemented in OpenGL on the driver side, are moved to the application level in Vulkan.

Vulkan covers all available platforms and provides a unified API for desktop, mobile systems, and the web, allowing the use of a single common API for various graphics processors and application domains. Thanks to Vulkan's layered architecture, which implies the creation of tools that work with any GPU, hardware manufacturers can utilize standard tools for code verification, debugging, and profiling during development. A new portable intermediate representation, SPIR-V, based on LLVM and leveraging the shared underlying technologies of OpenCL, is offered for shader creation. For device and screen management in Vulkan, a WSI (Window System Integration) interface is proposed, addressing roughly the same tasks as EGL in OpenGL ES. Out-of-the-box support for WSI is available in Wayland; all applications using Vulkan can run in environments with unmodified Wayland servers. WSI support is also provided for Android, X11 (with DRI3), Windows, Tizen, macOS, and iOS.

Source: opennet.ru