इस पेज का अनुवाद Cloud Translation API से किया गया है.

Android पर Vulkan की पुष्टि करने वाली लेयर

ज़्यादातर अश्लील ग्राफ़िक्स एपीआई, गड़बड़ी की जांच नहीं करते, क्योंकि ऐसा करने से परफ़ॉर्मेंस पर असर पड़ सकता है. Vulkan में पुष्टि करने वाली लेयर होती हैं. ये डेवलपमेंट के दौरान गड़बड़ी की जांच करती हैं. इससे आपके ऐप्लिकेशन के रिलीज़ बिल्ड में परफ़ॉर्मेंस में कमी नहीं आती. पुष्टि करने वाली लेयर, सामान्य काम के लिए लेयरिंग मैकेनिज्म पर निर्भर करती हैं. यह मैकेनिज्म, एपीआई एंट्री पॉइंट को इंटरसेप्ट करता है.

Khronos की पुष्टि करने वाली एक लेयर

पहले, Vulkan कई पुष्टि करने वाली लेयर उपलब्ध कराता था. इन्हें किसी खास क्रम में चालू करना होता था. Vulkan SDK के 1.1.106.0 वर्शन से, आपके ऐप्लिकेशन को पुष्टि करने वाली पिछली सभी लेयर की सुविधाएं पाने के लिए, सिर्फ़ पुष्टि करने वाली एक लेयर, VK_LAYER_KHRONOS_validation को चालू करना होगा.

अपने APK में पैकेज की गई पुष्टि करने वाली लेयर का इस्तेमाल करना

आपके APK में पैकेज की पुष्टि करने वाली लेयर, बेहतर तरीके से काम करने की पुष्टि करती हैं. पुष्टि करने वाली लेयर, पहले से बनी बाइनरी के तौर पर उपलब्ध होती हैं या इन्हें सोर्स कोड से बनाया जा सकता है.

पहले से बने बाइनरी का इस्तेमाल करना

GitHub रिलीज़ पेज से, Android Vulkan की पुष्टि करने वाली लेयर की नई बाइनरी डाउनलोड करें.

अपने APK में लेयर जोड़ने का सबसे आसान तरीका यह है कि पहले से बनी लेयर के बाइनरी को अपने मॉड्यूल की src/main/jniLibs/ डायरेक्ट्री में निकाला जाए. साथ ही, ABI डायरेक्ट्री (जैसे, arm64-v8a या x86-64) को बरकरार रखा जाए. ऐसा करने का तरीका यहां बताया गया है:

src/main/jniLibs/
  arm64-v8a/
    libVkLayer_khronos_validation.so
  armeabi-v7a/
    libVkLayer_khronos_validation.so
  x86/
    libVkLayer_khronos_validation.so
  x86-64/
    libVkLayer_khronos_validation.so

सोर्स कोड से पुष्टि करने की लेयर बनाना

पुष्टि करने वाली लेयर के सोर्स कोड को डीबग करने के लिए, Khronos Group के GitHub रिपॉज़िटरी से नया सोर्स पुल करें और वहां दिए गए बिल्ड करने के निर्देशों का पालन करें.

पुष्टि करें कि पुष्टि करने वाली लेयर को सही तरीके से पैक किया गया है

भले ही, आपने Khronos की पहले से बनी लेयर या सोर्स से बनाई गई लेयर का इस्तेमाल करके बिल्ड किया हो, बिल्ड करने की प्रोसेस से आपके APK में फ़ाइनल फ़ाइल स्ट्रक्चर बनता है. यह स्ट्रक्चर इस तरह का होता है:

lib/
  arm64-v8a/
    libVkLayer_khronos_validation.so
  armeabi-v7a/
    libVkLayer_khronos_validation.so
  x86/
    libVkLayer_khronos_validation.so
  x86-64/
    libVkLayer_khronos_validation.so

नीचे दिए गए निर्देश से यह पुष्टि करने का तरीका पता चलता है कि आपके APK में पुष्टि करने वाली लेयर, उम्मीद के मुताबिक है या नहीं:

$ jar -tf project.apk | grep libVkLayer
lib/x86_64/libVkLayer_khronos_validation.so
lib/armeabi-v7a/libVkLayer_khronos_validation.so
lib/arm64-v8a/libVkLayer_khronos_validation.so
lib/x86/libVkLayer_khronos_validation.so

इंस्टेंस बनाते समय पुष्टि करने की सुविधा चालू करना

Vulkan API की मदद से, ऐप्लिकेशन इंस्टेंस बनाते समय लेयर चालू की जा सकती हैं. किसी लेयर के इंटरसेप्ट किए गए एंट्री पॉइंट के पहले पैरामीटर के तौर पर, इनमें से कोई एक ऑब्जेक्ट होना चाहिए:

VkInstance
VkPhysicalDevice
VkDevice
VkCommandBuffer
VkQueue

उपलब्ध लेयर और उनकी प्रॉपर्टी की सूची देखने के लिए, vkEnumerateInstanceLayerProperties() को कॉल करें. Vulkan, vkCreateInstance() के लागू होने पर लेयर चालू करता है.

नीचे दिए गए कोड स्निपेट में बताया गया है कि कोई ऐप्लिकेशन, प्रोग्राम के हिसाब से लेयर की क्वेरी करने और उन्हें चालू करने के लिए, Vulkan API का इस्तेमाल कैसे कर सकता है:

// Enable just the Khronos validation layer.
static const char *layers[] = {"VK_LAYER_KHRONOS_validation"};

// Get the layer count using a null pointer as the last parameter.
uint32_t instance_layer_present_count = 0;
vkEnumerateInstanceLayerProperties(&instance_layer_present_count, nullptr);

// Enumerate layers with a valid pointer in the last parameter.
VkLayerProperties layer_props[instance_layer_present_count];
vkEnumerateInstanceLayerProperties(&instance_layer_present_count, layer_props);

// Make sure selected validation layers are available.
VkLayerProperties *layer_props_end = layer_props + instance_layer_present_count;
for (const char* layer:layers) {
  assert(layer_props_end !=
  std::find_if(layer_props, layer_props_end, [layer](VkLayerProperties layerProperties) {
    return strcmp(layerProperties.layerName, layer) == 0;
  }));
}

// Create a Vulkan instance, requesting all enabled layers or extensions
// available on the system
VkInstanceCreateInfo instanceCreateInfo{
  .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
  .pNext = nullptr,
  .pApplicationInfo = &appInfo,
  .enabledLayerCount = sizeof(layers) / sizeof(layers[0]),
  .ppEnabledLayerNames = layers,

डिफ़ॉल्ट logcat आउटपुट

पुष्टि करने वाली लेयर, VALIDATION टैग के साथ लेबल किए गए logcat में चेतावनी और गड़बड़ी के मैसेज भेजती है. पुष्टि करने वाली लेयर का मैसेज इस तरह दिखता है. इसमें आसानी से स्क्रोल करने के लिए, लाइन ब्रेक जोड़े गए हैं:

Validation -- Validation Error:
  [ VUID-VkDeviceQueueCreateInfo-pQueuePriorities-parameter ]
Object 0: VK_NULL_HANDLE, type = VK_OBJECT_TYPE_DEVICE; | MessageID = 0xd6d720c6 |
vkCreateDevice: required parameter
  pCreateInfo->pQueueCreateInfos[0].pQueuePriorities specified as NULL.
The Vulkan spec states: pQueuePriorities must be a valid pointer to an array of
  queueCount float values
  (https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html
  #VUID-VkDeviceQueueCreateInfo-pQueuePriorities-parameter)

डीबग कॉलबैक की सुविधा चालू करना

Debug Utils एक्सटेंशन VK_EXT_debug_utils की मदद से, आपके ऐप्लिकेशन में एक डिबग मैसेंजर बनाया जा सकता है. यह मैसेंजर, पुष्टि करने वाली लेयर के मैसेज को ऐप्लिकेशन से दिए गए कॉलबैक पर भेजता है. ऐसा हो सकता है कि आपके डिवाइस पर यह एक्सटेंशन लागू न हो. हालांकि, पुष्टि करने वाली सबसे नई लेयर में इसे लागू किया गया है. VK_EXT_debug_report नाम का एक और एक्सटेंशन है, जो अब काम नहीं करता. हालांकि, VK_EXT_debug_utils के उपलब्ध न होने पर, यह एक्सटेंशन भी मिलती-जुलती सुविधाएं देता है.

Debug Utils एक्सटेंशन का इस्तेमाल करने से पहले, आपको यह पक्का करना होगा कि आपका डिवाइस या पुष्टि करने के लिए लोड की गई लेयर, इसके साथ काम करती हो. इस उदाहरण में, यह जांचने का तरीका बताया गया है कि डिवाइस या पुष्टि करने वाली लेयर में, डीबग करने के लिए इस्तेमाल होने वाले टूल का एक्सटेंशन काम करता है या नहीं. साथ ही, अगर एक्सटेंशन काम करता है, तो कॉलबैक रजिस्टर करने का तरीका भी बताया गया है.

// Get the instance extension count.
uint32_t inst_ext_count = 0;
vkEnumerateInstanceExtensionProperties(nullptr, &inst_ext_count, nullptr);

// Enumerate the instance extensions.
VkExtensionProperties inst_exts[inst_ext_count];
vkEnumerateInstanceExtensionProperties(nullptr, &inst_ext_count, inst_exts);

// Check for debug utils extension within the system driver or loader.
// Check if the debug utils extension is available (in the driver).
VkExtensionProperties *inst_exts_end = inst_exts + inst_ext_count;
bool debugUtilsExtAvailable = inst_exts_end !=
  std::find_if(inst_exts, inst_exts_end, [](VkExtensionProperties
    extensionProperties) {
    return strcmp(extensionProperties.extensionName,
      VK_EXT_DEBUG_UTILS_EXTENSION_NAME) == 0;
  });

if ( !debugUtilsExtAvailable ) {
  // Also check the layers for the debug utils extension.
  for (auto layer: layer_props) {
    uint32_t layer_ext_count;
    vkEnumerateInstanceExtensionProperties(layer.layerName, &layer_ext_count,
      nullptr);
    if (layer_ext_count == 0) continue;
    VkExtensionProperties layer_exts[layer_ext_count];
    vkEnumerateInstanceExtensionProperties(layer.layerName, &layer_ext_count,
    layer_exts);

    VkExtensionProperties * layer_exts_end = layer_exts + layer_ext_count;
    debugUtilsExtAvailable = layer_exts != std::find_if(
      layer_exts, layer_exts_end,[](VkExtensionProperties extensionProperties) {
        return strcmp(extensionProperties.extensionName,
        VK_EXT_DEBUG_UTILS_EXTENSION_NAME) == 0;
      });
    if (debugUtilsExtAvailable) {
        // Add the including layer into the layer request list if necessary.
        break;
    }
  }
}

if (!debugUtilsExtAvailable) return; // since this snippet depends on debugUtils

const char * enabled_inst_exts[] = { ..., VK_EXT_DEBUG_UTILS_EXTENSION_NAME };
uint32_t enabled_extension_count =
  sizeof(enabled_inst_exts)/sizeof(enabled_inst_exts[0]);

// Pass the instance extensions into vkCreateInstance.
VkInstanceCreateInfo instance_info = {};
instance_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instance_info.enabledExtensionCount = enabled_extension_count;
instance_info.ppEnabledExtensionNames = enabled_inst_exts;

// NOTE: Can still return VK_ERROR_EXTENSION_NOT_PRESENT if validation layer
// isn't loaded.
vkCreateInstance(&instance_info, nullptr, &instance);

auto pfnCreateDebugUtilsMessengerEXT =
  (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(
    tutorialInstance, "vkCreateDebugUtilsMessengerEXT");
auto pfnDestroyDebugUtilsMessengerEXT =
  (PFN_vkDestroyDebugUtilsMessengerEXT)vkGetInstanceProcAddr(
    tutorialInstance, "vkDestroyDebugUtilsMessengerEXT");

// Create the debug messenger callback with your the settings you want.
VkDebugUtilsMessengerEXT debugUtilsMessenger;
if (pfnCreateDebugUtilsMessengerEXT) {
  VkDebugUtilsMessengerCreateInfoEXT messengerInfo;
  constexpr VkDebugUtilsMessageSeverityFlagsEXT kSeveritiesToLog =
    VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT |
    VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT;

constexpr VkDebugUtilsMessageTypeFlagsEXT kMessagesToLog =
  VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT |
  VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT |
  VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT;

  messengerInfo.sType           = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
  messengerInfo.pNext           = nullptr;
  messengerInfo.flags           = 0;
  messengerInfo.messageSeverity = kSeveritiesToLog;
  messengerInfo.messageType     = kMessagesToLog;

  // The DebugUtilsMessenger callback is explained in the following section.
  messengerInfo.pfnUserCallback = &DebugUtilsMessenger;
  messengerInfo.pUserData       = nullptr; // Custom user data passed to callback

  pfnCreateDebugUtilsMessengerEXT(instance, &messengerInfo, nullptr,
    &debugUtilsMessenger);
}

// Later, when shutting down Vulkan, call the following:
if (pfnDestroyDebugUtilsMessengerEXT) {
    pfnDestroyDebugUtilsMessengerEXT(instance, debugUtilsMessenger, nullptr);
}

आपका ऐप्लिकेशन रजिस्टर होने और कॉलबैक चालू करने के बाद, सिस्टम उस पर डीबग करने के मैसेज भेजता है.

#include <android/log.h>

VKAPI_ATTR VkBool32 VKAPI_CALL DebugUtilsMessenger(
                        VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
                        VkDebugUtilsMessageTypeFlagsEXT messageTypes,
                        const VkDebugUtilsMessengerCallbackDataEXT *callbackData,
                        void *userData)
{
  const char validation[]  = "Validation";
  const char performance[] = "Performance";
  const char error[]       = "ERROR";
  const char warning[]     = "WARNING";
  const char unknownType[] = "UNKNOWN_TYPE";
  const char unknownSeverity[] = "UNKNOWN_SEVERITY";
  const char* typeString      = unknownType;
  const char* severityString  = unknownSeverity;
  const char* messageIdName   = callbackData->pMessageIdName;
  int32_t messageIdNumber     = callbackData->messageIdNumber;
  const char* message         = callbackData->pMessage;
  android_LogPriority priority = ANDROID_LOG_UNKNOWN;

  if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) {
    severityString = error;
    priority = ANDROID_LOG_ERROR;
  }
  else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) {
    severityString = warning;
    priority = ANDROID_LOG_WARN;
  }
  if (messageTypes & VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT) {
     typeString = validation;
  }
  else if (messageTypes & VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT) {
     typeString = performance;
  }

  __android_log_print(priority,
                     "AppName",
                     "%s %s: [%s] Code %i : %s",
                     typeString,
                     severityString,
                     messageIdName,
                     messageIdNumber,
                     message);

  // Returning false tells the layer not to stop when the event occurs, so
  // they see the same behavior with and without validation layers enabled.
  return VK_FALSE;
}

बाहरी पुष्टि करने वाली लेयर का इस्तेमाल करना

आपको अपने APK में पुष्टि करने वाली लेयर को पैकेज करने की ज़रूरत नहीं है. Android 9 (एपीआई लेवल 28) और इसके बाद के वर्शन वाले डिवाइस, आपकी बाइनरी के बाहर की पुष्टि करने वाली लेयर का इस्तेमाल कर सकते हैं. साथ ही, उन्हें डाइनैमिक तौर पर बंद और चालू कर सकते हैं. पुष्टि करने वाली लेयर को अपने टेस्ट डिवाइस पर पुश करने के लिए, इस सेक्शन में दिया गया तरीका अपनाएं:

अपने ऐप्लिकेशन को पुष्टि करने के लिए, बाहरी लेयर का इस्तेमाल करने की अनुमति देना

Android का सुरक्षा मॉडल और नीतियां, दूसरे प्लैटफ़ॉर्म से काफ़ी अलग हैं. बाहरी पुष्टि करने वाली लेयर लोड करने के लिए, इनमें से कोई एक शर्त पूरी होनी चाहिए:

टारगेट ऐप्लिकेशन को डीबग किया जा सकता है. इस विकल्प की मदद से, डीबग करने के बारे में ज़्यादा जानकारी मिलती है. हालांकि, इससे आपके ऐप्लिकेशन की परफ़ॉर्मेंस पर बुरा असर पड़ सकता है.
टारगेट ऐप्लिकेशन, ऑपरेटिंग सिस्टम के userdebug बिल्ड पर चलता है, जो रूट ऐक्सेस देता है.
सिर्फ़ Android 11 (एपीआई लेवल 30) या उसके बाद के वर्शन को टारगेट करने वाले ऐप्लिकेशन: आपकी टारगेट Android manifest फ़ाइल में, यह meta-data एलिमेंट शामिल है:
```
<meta-data android:name="com.android.graphics.injectLayers.enable"
  android:value="true"/>
```

पुष्टि करने वाली बाहरी लेयर लोड करना

Android 9 (एपीआई लेवल 28) और उसके बाद के वर्शन वाले डिवाइसों पर, Vulkan आपके ऐप्लिकेशन के लोकल स्टोरेज से पुष्टि करने वाली लेयर को लोड कर सकता है. Android 10 (एपीआई लेवल 29) से, Vulkan, पुष्टि करने वाली लेयर को अलग APK से भी लोड कर सकता है. आपके पास अपनी पसंद का कोई भी तरीका चुनने का विकल्प होता है. हालांकि, यह ज़रूरी है कि आपके Android वर्शन पर वह तरीका काम करता हो.

अपने डिवाइस के स्टोरेज से पुष्टि करने वाली लेयर की बाइनरी लोड करना

Vulkan, आपके डिवाइस के कुछ समय के लिए सेव किए गए डेटा की स्टोरेज डायरेक्ट्री में बाइनरी खोजता है. इसलिए, आपको पहले Android डीबग ब्रिज (adb) का इस्तेमाल करके, बाइनरी को उस डायरेक्ट्री में पुश करना होगा. इसके लिए, यह तरीका अपनाएं:

डिवाइस पर अपने ऐप्लिकेशन के डेटा स्टोरेज में लेयर बाइनरी को लोड करने के लिए, adb push कमांड का इस्तेमाल करें:
```
$ adb push libVkLayer_khronos_validation.so /data/local/tmp
```
ऐप्लिकेशन की प्रोसेस के ज़रिए लेयर लोड करने के लिए, adb shell और run-as कमांड का इस्तेमाल करें. इसका मतलब है कि बाइनरी के पास डिवाइस का वही ऐक्सेस है जो ऐप्लिकेशन के पास है. इसके लिए, रूट ऐक्सेस की ज़रूरत नहीं होती.
```
$ adb shell run-as com.example.myapp cp
  /data/local/tmp/libVkLayer_khronos_validation.so .
$ adb shell run-as com.example.myapp ls libVkLayer_khronos_validation.so
```
लेयर चालू करें.

पुष्टि करने वाली लेयर की बाइनरी को किसी दूसरे APK से लोड करना

adb का इस्तेमाल करके, ऐसा APK इंस्टॉल किया जा सकता है जिसमें लेयर शामिल हो. इसके बाद, लेयर को चालू किया जा सकता है.

adb install --abi abi path_to_apk

ऐप्लिकेशन के बाहर लेयर चालू करना

Vulkan लेयर को हर ऐप्लिकेशन के लिए या पूरी दुनिया के लिए चालू किया जा सकता है. हर ऐप्लिकेशन के लिए सेटिंग, रीबूट होने पर भी बनी रहती हैं. वहीं, ग्लोबल प्रॉपर्टी रीबूट होने पर मिट जाती हैं.

हर ऐप्लिकेशन के लिए लेयर चालू करना

हर ऐप्लिकेशन के लिए लेयर चालू करने का तरीका यहां बताया गया है:

लेयर चालू करने के लिए, adb shell सेटिंग का इस्तेमाल करें:
```
$ adb shell settings put global enable_gpu_debug_layers 1
```
लेयर चालू करने के लिए, टारगेट किए गए ऐप्लिकेशन की जानकारी दें:
```
$ adb shell settings put global gpu_debug_app <package_name>
```
चालू करने के लिए लेयर की सूची दें (ऊपर से नीचे तक), हर लेयर को कोलन लगाकर अलग करें:
```
$ adb shell settings put global gpu_debug_layers <layer1:layer2:layerN>
```
हमारे पास पुष्टि करने के लिए, Khronos की एक लेयर है. इसलिए, कमांड इस तरह दिखेगा:
```
$ adb shell settings put global gpu_debug_layers VK_LAYER_KHRONOS_validation
```
इनमें लेयर खोजने के लिए, एक या उससे ज़्यादा पैकेज तय करें:
```
$ adb shell settings put global
  gpu_debug_layer_app <package1:package2:packageN>
```

ध्यान दें: डिवाइस पर मौजूद डेवलपर के विकल्पों की मदद से भी enable_gpu_debug_layers सेटिंग को चालू किया जा सकता है. डेवलपर के लिए सेटिंग और टूल चालू करने के बाद, जांच के लिए इस्तेमाल किए जा रहे डिवाइस पर सेटिंग ऐप्लिकेशन खोलें. इसके बाद, डेवलपर के लिए सेटिंग और टूल > डीबग करना पर जाएं और पक्का करें कि GPU डीबग लेयर चालू करें विकल्प चालू हो.

इन निर्देशों का इस्तेमाल करके, यह देखा जा सकता है कि सेटिंग चालू हैं या नहीं:

$ adb shell settings list global | grep gpu
enable_gpu_debug_layers=1
gpu_debug_app=com.example.myapp
gpu_debug_layers=VK_LAYER_KHRONOS_validation

डिवाइस को रीबूट करने पर भी, लागू की गई सेटिंग बनी रहती हैं. इसलिए, लेयर लोड होने के बाद, सेटिंग मिटाई जा सकती हैं:

$ adb shell settings delete global enable_gpu_debug_layers
$ adb shell settings delete global gpu_debug_app
$ adb shell settings delete global gpu_debug_layers
$ adb shell settings delete global gpu_debug_layer_app

दुनिया भर में लेयर चालू करना

अगले रीबूट तक, एक या उससे ज़्यादा लेयर को दुनिया भर में चालू किया जा सकता है. यह सभी ऐप्लिकेशन के लिए लेयर लोड करने की कोशिश करता है. इनमें नेटिव एक्सीक्यूटेबल भी शामिल हैं.

$ adb shell setprop debug.vulkan.layers <layer1:layer2:layerN>