Vulkan 1.2 graphics standard published

The Khronos Consortium, which develops graphics standards,
опубликовал specification Vulkan 1.2, which defines an API for accessing the graphics and computing capabilities of the GPU. The new specification incorporates corrections accumulated over two years and expansion. Drivers supporting the new version of Vulkan are already released Intel, AMD, ARM, Imagination Technologies and NVIDIA. Mesa offers Vulkan 1.2 support for drivers RADV (AMD cards) and ANV (Intel). Vulkan 1.2 support also implemented in the debugger RenderDoc 1.6, LunarG Vulkan SDK and a set of examples Vulkan Samples.

All innovations:

• brought until ready for widespread use implementation of the shader programming language HLSL, developed by Microsoft for DirectX. HLSL support in Vulkan makes it possible to use the same HLSL shaders in applications based on Vulkan and DirectX, and also simplifies translation from HLSL to SPIR-V. To compile shaders, it is proposed to use a regular compiler
  DXC, which was opened by Microsoft in 2017 and is based on LLVM technology. Vulkan support is implemented through a separate backend that allows you to translate HLSL into an intermediate representation of SPIR-V shaders. Implementation covers more than all built-in features
  HLSL, including math types, control flows, functions, sets, resource types, namespaces, Shader Model 6.2, structures and methods, but also allows for Vulkan-specific extensions such as NVIDIA's VKRay. HLSL mode over Vulkan was able to organize the work of such games as Destiny 2, Red Dead Redemption II, Assassin's Creed Odyssey and Tomb Raider.
  

• Specification updated SPIR-V 1.5, which defines an intermediate representation of shaders that is universal for all platforms and can be used for both graphics and parallel computing.
  SPIR-V implies the separation of a separate shader compilation phase into an intermediate representation, which allows you to create frontends for various high-level languages. Based on various high-level implementations, a single intermediate code is separately generated that can be used by OpenGL, Vulkan and OpenCL drivers without using the built-in shader compiler.
  

• The core Vulkan API includes 23 extensions to improve performance, render quality, and simplify development. Added extensions include:
  • Chronological semaphores (Timeline semaphore), unifying synchronization with the host and device queues (allow one primitive for omnidirectional synchronization between the device and the host, without using separate VkFence and VkSemaphore primitives). New semaphores are represented by a monotonically increasing 64-bit value that can be tracked and updated across multiple threads.
    

  • Ability to use numeric types with reduced precision in shaders;
  • HLSL compatible memory layout option;
  • Unbound resources (bindless), removing the limit on the number of resources available to shaders due to the use of a common virtual space of system memory and GPU memory;
  • Formal memory model, which defines how concurrently executing threads can access shared data and synchronization operations;
  • Descriptor indexing for reusing layout descriptors in multiple shaders;
  • buffer links.

  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
• Posted more than 50 new structures and 13 functions;
• Shortened versions of the specification for typical target platforms have been prepared to simplify work on platforms for which all extensions are not yet supported, and to avoid selective activation of the basic features of the Vulkan API.
• Continued work on the project to ensure portability with other graphics APIs. For example, Vulkan offers extensions that allow you to translate OpenGL (Zinc), OpenCL (clspv, clvk), OpenGL ES (GLOVE, Angle) and DirectX (DXVK extension, vkd3d) through the Vulkan API, and vice versa to make Vulkan work on platforms without its native support (gfx-rs и Ashes to work on top of OpenGL and DirectX, MoltenVK and gfx-rs to work on top of Metal).
  Added extensions to improve compatibility with DirectX and HLSL
  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 also HLSL-specific features are implemented in SPIR-V.

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

Recall that the Vulkan API remarkable cardinal simplification of drivers, removal of GPU command generation to the application side, the ability to connect debug layers, API unification for various platforms and the use of a precompiled intermediate code representation for execution on the GPU side. To ensure high performance and predictability, Vulkan provides applications with direct control over GPU operations and built-in support for GPU multithreading, which minimizes the overhead introduced by the driver, and the capabilities implemented on the driver side are much simpler and more predictable. For example, operations such as memory management and error handling implemented in OpenGL on the driver side are moved to the application layer in Vulkan.

Vulkan spans all available platforms and provides a single API across desktop, mobile, and the Web, allowing one common API to be used across multiple GPUs and applications. With Vulkan's multi-layered architecture that builds tools that work with any GPU, OEMs can use generic tools for code review, debugging, and profiling when developing. To create shaders, a new portable intermediate representation SPIR-V is proposed, based on LLVM and using the same basic technologies as OpenCL. To manage devices and screens, Vulkan offers the WSI (Window System Integration) interface, which solves approximately the same tasks as EGL in OpenGL ES. WSI support is available out of the box in Wayland - all applications using Vulkan can run in an environment of unmodified Wayland servers. The ability to work through WSI is also provided for Android, X11 (with DRI3), Windows, Tizen, macOS and iOS.

Source: opennet.ru