JBR-8608 Vulkan: Cleanup capability checks

Author: YaaZ

src/java.desktop/share/classes/sun/java2d/vulkan/VKBlitLoops.java

@@ -546,7 +546,7 @@ private static int encode3Byte(int r, int g, int b) {
     }
 
     private static boolean hasCap(VKSurfaceData dst, int cap) {
-        return (dst.getGraphicsConfig().getGPU().getCaps() & cap) != 0;
+        return dst.getGraphicsConfig().getGPU().hasCap(cap);
     }
 
     /**

src/java.desktop/share/classes/sun/java2d/vulkan/VKEnv.java

@@ -80,7 +80,7 @@ public static synchronized void init(long nativePtr) {
                         Options.deviceNumber : 0];
                 // Check whether the presentation is supported.
                 for (VKGPU device : devices) {
-                    if ((device.getCaps() & VKGPU.CAP_PRESENTABLE_BIT) != 0 &&
+                    if (device.hasCap(VKGPU.CAP_PRESENTABLE_BIT) &&
                             device.getPresentableGraphicsConfigs().findAny().isPresent()) {
                         newState |= PRESENT_BIT;
                         break;

src/java.desktop/share/classes/sun/java2d/vulkan/VKGPU.java

@@ -39,6 +39,7 @@
 public class VKGPU {
 
     @Native public static final int CAP_PRESENTABLE_BIT = 0x80000000;
+    @Native public static final int CAP_LOGIC_OP_BIT    = 0x40000000;
     @Native public static final int CAP_SAMPLED_4BYTE_BIT = 0; // Considered always supported.
     @Native public static final int CAP_SAMPLED_3BYTE_BIT = 1;
     @Native public static final int CAP_SAMPLED_565_BIT   = 2;
@@ -98,6 +99,10 @@ public int getCaps() {
         return caps;
     }
 
+    public boolean hasCap(int cap) {
+        return (caps & cap) == cap;
+    }
+
     /**
      * Initialize the device and return its native handle.
      */

src/java.desktop/share/native/common/java2d/vulkan/VKCapabilityUtil.h

@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2023, JetBrains s.r.o.. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#ifndef VKCapabilityUtil_h_Included
+#define VKCapabilityUtil_h_Included
+#include "VKUtil.h"
+
+#define VK_KHR_VALIDATION_LAYER_NAME "VK_LAYER_KHRONOS_validation"
+
+// Named entries are layers or extensions, arragned into on-stack linked list.
+typedef struct VKNamedEntry {
+    pchar       name;
+    const void* found; // Pointer to the found struct.
+    struct VKNamedEntry* next; // Pointer to the next entry.
+} VKNamedEntry;
+
+#define DEF_NAMED_ENTRY(LIST, NAME) VKNamedEntry NAME = { NAME ## _NAME, NULL, (LIST) }; \
+    if (NAME.name != NULL) (LIST) = &(NAME)
+
+static void VKNamedEntry_LogAll(pchar what, pchar all, uint32_t count, size_t stride) {
+    J2dRlsTraceLn1(J2D_TRACE_VERBOSE, "    Supported %s:", what)
+    for (uint32_t i = 0; i < count; i++) {
+        if (i == 0) J2dRlsTrace(J2D_TRACE_VERBOSE, "            ")
+        else J2dRlsTrace(J2D_TRACE_VERBOSE, ", ")
+        J2dRlsTrace(J2D_TRACE_VERBOSE, all)
+        all += stride;
+    }
+    J2dRlsTrace(J2D_TRACE_VERBOSE, "\n")
+}
+
+static void VKNamedEntry_LogFound(const VKNamedEntry* list) {
+    for (; list != NULL; list = list->next) {
+        J2dRlsTraceLn2(J2D_TRACE_INFO, "    %s = %s", list->name, list->found ? "true" : "false")
+    }
+}
+
+static void VKNamedEntry_Match(VKNamedEntry* list, pchar all, uint32_t count, size_t stride) {
+    for (; list != NULL; list = list->next) {
+        pchar check = all;
+        for (uint32_t i = 0; i < count; i++) {
+            if (strcmp(list->name, check) == 0) {
+                list->found = check;
+                break;
+            }
+            check += stride;
+        }
+    }
+}
+
+static ARRAY(pchar) VKNamedEntry_CollectNames(const VKNamedEntry* list) {
+    ARRAY(pchar) result = NULL;
+    for (; list != NULL; list = list->next) {
+        if (list->found) ARRAY_PUSH_BACK(result) = list->name;
+    }
+    return result;
+}
+
+static void VKCapabilityUtil_LogErrors(int level, ARRAY(pchar) errors) {
+    for (uint32_t i = 0; i < ARRAY_SIZE(errors); i++) {
+        J2dRlsTraceLn1(level, "        %s", errors[i])
+    }
+}
+
+#endif //VKCapabilityUtil_h_Included

src/java.desktop/share/native/common/java2d/vulkan/VKDevice.c

@@ -27,6 +27,7 @@
 #include <string.h>
 #include "sun_java2d_vulkan_VKGPU.h"
 #include "VKUtil.h"
+#include "VKCapabilityUtil.h"
 #include "VKEnv.h"
 #include "VKAllocator.h"
 #include "VKRenderer.h"
@@ -71,7 +72,6 @@ static VkBool32 VKDevice_CheckAndAddFormat(VKEnv* vk, VkPhysicalDevice physicalD
 }
 
 void VKDevice_CheckAndAdd(VKEnv* vk, VkPhysicalDevice physicalDevice) {
-    jint caps = 0;
     // Query device properties.
     VkPhysicalDeviceVulkan12Features device12Features = {
             .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES,
@@ -85,27 +85,55 @@ void VKDevice_CheckAndAdd(VKEnv* vk, VkPhysicalDevice physicalDevice) {
     VkPhysicalDeviceProperties2 deviceProperties2 = {.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 };
     vk->vkGetPhysicalDeviceProperties2(physicalDevice, &deviceProperties2);
 
-    // Check features.
-    J2dRlsTrace5(J2D_TRACE_INFO, "\t- %s (%d.%d.%d, %s) ",
+    // Query supported layers.
+    uint32_t layerCount;
+    VK_IF_ERROR(vk->vkEnumerateDeviceLayerProperties(physicalDevice, &layerCount, NULL)) return;
+    VkLayerProperties allLayers[layerCount];
+    VK_IF_ERROR(vk->vkEnumerateDeviceLayerProperties(physicalDevice, &layerCount, allLayers)) return;
+
+    // Query supported extensions.
+    uint32_t extensionCount;
+    VK_IF_ERROR(vk->vkEnumerateDeviceExtensionProperties(physicalDevice, NULL, &extensionCount, NULL)) return;
+    VkExtensionProperties allExtensions[extensionCount];
+    VK_IF_ERROR(vk->vkEnumerateDeviceExtensionProperties(physicalDevice, NULL, &extensionCount, allExtensions)) return;
+
+    // Check API version.
+    ARRAY(pchar) errors = NULL;
+    jint caps = 0;
+    J2dRlsTraceLn5(J2D_TRACE_INFO, "%s (%d.%d.%d, %s)",
                  (const char *) deviceProperties2.properties.deviceName,
                  VK_API_VERSION_MAJOR(deviceProperties2.properties.apiVersion),
                  VK_API_VERSION_MINOR(deviceProperties2.properties.apiVersion),
                  VK_API_VERSION_PATCH(deviceProperties2.properties.apiVersion),
                  physicalDeviceTypeString(deviceProperties2.properties.deviceType))
     if (deviceProperties2.properties.apiVersion < REQUIRED_VULKAN_VERSION) {
-        J2dRlsTraceLn(J2D_TRACE_INFO, " - unsupported API version, skipped")
-        return;
+        ARRAY_PUSH_BACK(errors) = "Unsupported API version";
     }
 
-    if (!deviceFeatures2.features.logicOp) {
-        J2dRlsTraceLn(J2D_TRACE_INFO, " - hasLogicOp not supported, skipped")
-        return;
-    }
-    if (!device12Features.timelineSemaphore) {
-        J2dRlsTraceLn(J2D_TRACE_INFO, " - hasTimelineSemaphore not supported, skipped")
-        return;
-    }
-    J2dRlsTraceLn(J2D_TRACE_INFO, "")
+    // Log layers and extensions.
+    VKNamedEntry_LogAll("device layers", allLayers[0].layerName, layerCount, sizeof(VkLayerProperties));
+    VKNamedEntry_LogAll("device extensions", allExtensions[0].extensionName, extensionCount, sizeof(VkExtensionProperties));
+
+    // Check layers.
+    VKNamedEntry* layers = NULL;
+#ifdef DEBUG
+    DEF_NAMED_ENTRY(layers, VK_KHR_VALIDATION_LAYER);
+#endif
+    VKNamedEntry_Match(layers, allLayers[0].layerName, layerCount, sizeof(VkLayerProperties));
+    VKNamedEntry_LogFound(layers);
+
+    // Check extensions.
+    VKNamedEntry* extensions = NULL;
+    DEF_NAMED_ENTRY(extensions, VK_KHR_SWAPCHAIN_EXTENSION);
+    VKNamedEntry_Match(extensions, allExtensions[0].extensionName, extensionCount, sizeof(VkExtensionProperties));
+    VKNamedEntry_LogFound(extensions);
+
+    // Check features.
+    J2dRlsTraceLn1(J2D_TRACE_INFO, "    logicOp = %s", deviceFeatures2.features.logicOp ? "true" : "false")
+    if (deviceFeatures2.features.logicOp) caps |= sun_java2d_vulkan_VKGPU_CAP_LOGIC_OP_BIT;
+
+    J2dRlsTraceLn1(J2D_TRACE_INFO, "    timelineSemaphore = %s", device12Features.timelineSemaphore ? "true" : "false")
+    if (!device12Features.timelineSemaphore) ARRAY_PUSH_BACK(errors) = "timelineSemaphore not supported";
 
     // Query queue family properties.
     uint32_t queueFamilyCount = 0;
@@ -119,7 +147,8 @@ void VKDevice_CheckAndAdd(VKEnv* vk, VkPhysicalDevice physicalDevice) {
     int64_t queueFamily = -1;
     for (uint32_t j = 0; j < queueFamilyCount; j++) {
         VkBool32 presentationSupported = VK_FALSE;
-        if (vk->platformData != NULL && vk->platformData->checkPresentationSupport != NULL) {
+        if (vk->presentationSupported && VK_KHR_SWAPCHAIN_EXTENSION.found &&
+            vk->platformData != NULL && vk->platformData->checkPresentationSupport != NULL) {
             presentationSupported = vk->platformData->checkPresentationSupport(vk, physicalDevice, j);
         }
         char logFlags[5] = {
@@ -144,22 +173,7 @@ void VKDevice_CheckAndAdd(VKEnv* vk, VkPhysicalDevice physicalDevice) {
             }
         }
     }
-    if (queueFamily == -1) {
-        J2dRlsTraceLn(J2D_TRACE_INFO, "    --------------------- Suitable queue not found, skipped")
-        return;
-    }
-
-    // Query supported layers.
-    uint32_t layerCount;
-    VK_IF_ERROR(vk->vkEnumerateDeviceLayerProperties(physicalDevice, &layerCount, NULL)) return;
-    VkLayerProperties layers[layerCount];
-    VK_IF_ERROR(vk->vkEnumerateDeviceLayerProperties(physicalDevice, &layerCount, layers)) return;
-
-    // Query supported extensions.
-    uint32_t extensionCount;
-    VK_IF_ERROR(vk->vkEnumerateDeviceExtensionProperties(physicalDevice, NULL, &extensionCount, NULL)) return;
-    VkExtensionProperties extensions[extensionCount];
-    VK_IF_ERROR(vk->vkEnumerateDeviceExtensionProperties(physicalDevice, NULL, &extensionCount, extensions)) return;
+    if (queueFamily == -1) ARRAY_PUSH_BACK(errors) = "Suitable queue not found";
 
     // Query supported formats.
     J2dRlsTraceLn(J2D_TRACE_INFO, "    Supported device formats:")
@@ -208,11 +222,8 @@ void VKDevice_CheckAndAdd(VKEnv* vk, VkPhysicalDevice physicalDevice) {
 
     // Check sampled formats capabilities.
     if (SRCTYPE_4BYTE->format == VK_FORMAT_UNDEFINED) {
-        J2dRlsTraceLn(J2D_TRACE_INFO, " - 4-byte sampled format not found, skipped")
-        ARRAY_FREE(supportedFormats);
-        return;
-    }
-    caps |= sun_java2d_vulkan_VKGPU_CAP_SAMPLED_4BYTE_BIT;
+        ARRAY_PUSH_BACK(errors) = "4-byte sampled format not found";
+    } else caps |= sun_java2d_vulkan_VKGPU_CAP_SAMPLED_4BYTE_BIT;
     if (SRCTYPE_3BYTE->format != VK_FORMAT_UNDEFINED) caps |= sun_java2d_vulkan_VKGPU_CAP_SAMPLED_3BYTE_BIT;
     if (SRCTYPE_565->format != VK_FORMAT_UNDEFINED) caps |= sun_java2d_vulkan_VKGPU_CAP_SAMPLED_565_BIT;
     if (SRCTYPE_555->format != VK_FORMAT_UNDEFINED) caps |= sun_java2d_vulkan_VKGPU_CAP_SAMPLED_555_BIT;
@@ -222,61 +233,21 @@ void VKDevice_CheckAndAdd(VKEnv* vk, VkPhysicalDevice physicalDevice) {
         vk->vkGetPhysicalDeviceFormatProperties(physicalDevice, VK_FORMAT_S8_UINT, &formatProperties);
         if ((formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) != 0) {
             J2dRlsTraceLn1(J2D_TRACE_INFO, "        %s", "VK_FORMAT_S8_UINT (stencil)")
-        } else {
-            J2dRlsTraceLn(J2D_TRACE_INFO, " - VK_FORMAT_S8_UINT not supported, skipped")
-            ARRAY_FREE(supportedFormats);
-            return;
-        }
+        } else ARRAY_PUSH_BACK(errors) = "VK_FORMAT_S8_UINT not supported";
     }
 
-    // Log layers.
-    J2dRlsTraceLn(J2D_TRACE_VERBOSE, "    Supported device layers:")
-    for (uint32_t j = 0; j < layerCount; j++) {
-        J2dRlsTraceLn1(J2D_TRACE_VERBOSE, "        %s", (char *) layers[j].layerName)
-    }
-
-    // Check extensions.
-    J2dRlsTraceLn(J2D_TRACE_VERBOSE, "    Supported device extensions:")
-    VkBool32 hasSwapChain = VK_FALSE;
-    for (uint32_t j = 0; j < extensionCount; j++) {
-        J2dRlsTraceLn1(J2D_TRACE_VERBOSE, "        %s", (char *) extensions[j].extensionName)
-        hasSwapChain = hasSwapChain || strcmp(VK_KHR_SWAPCHAIN_EXTENSION_NAME, extensions[j].extensionName) == 0;
-    }
-    J2dRlsTraceLn(J2D_TRACE_VERBOSE, "Vulkan: Found device extensions:")
-    J2dRlsTraceLn1(J2D_TRACE_VERBOSE, "    " VK_KHR_SWAPCHAIN_EXTENSION_NAME " = %s", hasSwapChain ? "true" : "false")
-
-    if (!hasSwapChain) {
-        J2dRlsTraceLn(J2D_TRACE_INFO,
-                    "    --------------------- Required " VK_KHR_SWAPCHAIN_EXTENSION_NAME " not found, skipped")
-        ARRAY_FREE(supportedFormats);
+    // Check found errors.
+    if (errors != NULL) {
+        J2dRlsTraceLn(J2D_TRACE_WARNING, "    Device is not supported:")
+        VKCapabilityUtil_LogErrors(J2D_TRACE_WARNING, errors);
+        ARRAY_FREE(errors);
         return;
     }
 
-    ARRAY(pchar) deviceEnabledLayers     = NULL;
-    ARRAY(pchar) deviceEnabledExtensions = NULL;
-    ARRAY_PUSH_BACK(deviceEnabledExtensions) = VK_KHR_SWAPCHAIN_EXTENSION_NAME;
-
-    // Check validation layer.
-#ifdef DEBUG
-    int validationLayerNotSupported = 1;
-        for (uint32_t j = 0; j < layerCount; j++) {
-            if (strcmp("VK_LAYER_KHRONOS_validation", layers[j].layerName) == 0) {
-                validationLayerNotSupported = 0;
-                ARRAY_PUSH_BACK(deviceEnabledLayers) = "VK_LAYER_KHRONOS_validation";
-                break;
-            }
-        }
-        if (validationLayerNotSupported) {
-            J2dRlsTraceLn1(J2D_TRACE_INFO, "    %s device layer is not supported", "VK_LAYER_KHRONOS_validation")
-        }
-#endif
-
     // Copy device name.
     char* deviceName = strdup(deviceProperties2.properties.deviceName);
     if (deviceName == NULL) {
-        J2dRlsTraceLn(J2D_TRACE_ERROR, "Vulkan: Cannot duplicate deviceName")
-        ARRAY_FREE(deviceEnabledLayers);
-        ARRAY_FREE(deviceEnabledExtensions);
+        J2dRlsTraceLn(J2D_TRACE_ERROR, "    Cannot duplicate deviceName")
         ARRAY_FREE(supportedFormats);
         return;
     }
@@ -288,8 +259,8 @@ void VKDevice_CheckAndAdd(VKEnv* vk, VkPhysicalDevice physicalDevice) {
         .handle = VK_NULL_HANDLE,
         .physicalDevice = physicalDevice,
         .queueFamily = queueFamily,
-        .enabledLayers = deviceEnabledLayers,
-        .enabledExtensions = deviceEnabledExtensions,
+        .enabledLayers = VKNamedEntry_CollectNames(layers),
+        .enabledExtensions = VKNamedEntry_CollectNames(extensions),
         .sampledSrcTypes = sampledSrcTypes,
         .supportedFormats = supportedFormats,
         .caps = caps