ProHoster > Blog > internet news > Vulkan 1.3 graphics standard published

Vulkan 1.3 graphics standard published

After two years of work, the graphics standards consortium Khronos has published the Vulkan 1.3 specification, which defines an API for accessing the graphics and computing capabilities of GPUs. The new specification incorporates corrections and extensions accumulated over two years. It is noted that the requirements of the Vulkan 1.3 specification are designed for OpenGL ES 3.1 class graphics equipment, which will ensure support for the new graphics API in all GPUs that support Vulkan 1.2. The Vulkan SDK tools are planned to be published in mid-February. In addition to the main specification, it is planned to offer additional extensions for mid-range and high-end mobile and desktop devices, which will be supported as part of the β€œVulkan Milestone” edition.

At the same time, a plan is presented to implement support for the new specification and additional extensions in graphics cards and device drivers. Intel, AMD, ARM and NVIDIA are preparing to release products supporting Vulkan 1.3. For example, AMD announced that it will soon support Vulkan 1.3 in the AMD Radeon RX Vega series of graphics cards, as well as in all cards based on the AMD RDNA architecture. NVIDIA is preparing to publish drivers with support for Vulkan 1.3 for Linux and Windows. ARM will add support for Vulkan 1.3 to Mali GPUs.

Main innovations:

  • Support for simplified rendering passes (Streamlining Render Passes, VK_KHR_dynamic_rendering) has been implemented, allowing you to start rendering without creating rendering passes and framebuffer objects.
  • New extensions have been added to simplify the management of graphics pipeline compilation (pipeline, a set of operations that turns vector graphics primitives and textures into pixel representations).
    • VK_EXT_extended_dynamic_state, VK_EXT_extended_dynamic_state2 - add additional dynamic states to reduce the number of compiled and attached state objects.
    • VK_EXT_pipeline_creation_cache_control - Provides advanced controls over when and how pipelines are compiled.
    • VK_EXT_pipeline_creation_feedback - Provides information about compiled pipelines to make profiling and debugging easier.
  • A number of features have been transferred from optional to mandatory. For example, the implementation of buffer references (VK_KHR_buffer_device_address) and the Vulkan memory model, which defines how concurrent threads can access shared data and synchronization operations, are now mandatory.
  • Fine-grained subgroup control (VK_EXT_subgroup_size_control) is provided so that vendors can provide support for multiple subgroup sizes and developers can select the size they require.
  • The VK_KHR_shader_integer_dot_product extension has been provided, which can be used to optimize the performance of machine learning frameworks thanks to hardware acceleration of dot product operations.
  • A total of 23 new expansions are included:
    • VK_KHR_copy_commands2
    • VK_KHR_dynamic_rendering
    • VK_KHR_format_feature_flags2
    • VK_KHR_maintenance4
    • VK_KHR_shader_integer_dot_product
    • VK_KHR_shader_non_semantic_info
    • VK_KHR_shader_terminate_invocation
    • VK_KHR_synchronization2
    • VK_KHR_zero_initialize_workgroup_memory
    • VK_EXT_4444_formats
    • VK_EXT_extended_dynamic_state
    • VK_EXT_extended_dynamic_state2
    • VK_EXT_image_robustness
    • VK_EXT_inline_uniform_block
    • VK_EXT_pipeline_creation_cache_control
    • VK_EXT_pipeline_creation_feedback
    • VK_EXT_private_data
    • VK_EXT_shader_demote_to_helper_invocation
    • VK_EXT_subgroup_size_control
    • VK_EXT_texel_buffer_alignment
    • VK_EXT_texture_compression_astc_hdr
    • VK_EXT_tooling_info
    • VK_EXT_ycbcr_2plane_444_formats
  • Added a new object type VkPrivateDataSlot. 37 new commands and more than 60 structures were implemented.
  • The SPIR-V 1.6 specification has been updated to define an intermediate shader representation that is universal for all platforms and can be used for both graphics and parallel computing. SPIR-V involves separating 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, which can be used by OpenGL, Vulkan and OpenCL drivers without using the built-in shader compiler.
  • The concept of compatibility profiles is proposed. Google is the first to release a baseline profile for the Android platform, which will make it easier to determine the level of support for advanced Vulkan capabilities on a device beyond the Vulkan 1.0 specification. For most devices, profile support can be provided without installing OTA updates.

Let us recall that the Vulkan API is notable for its radical simplification of drivers, the transfer of the generation of GPU commands to the application side, the ability to connect debugging layers, the unification of the API for various platforms and the use of a precompiled intermediate representation of code for execution on the GPU side. To ensure high performance and predictability, Vulkan provides applications with direct control over GPU operations and native support for GPU multi-threading, which minimizes driver overhead and makes driver-side capabilities 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 level 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

Add a comment