יישום וולקן

Vulkan הוא ממשק API חוצה פלטפורמות בעל תקורה נמוכה עבור גרפיקה תלת מימדית בעלת ביצועים גבוהים. כמו OpenGL ES (GLES) , Vulkan מספקת כלים ליצירת גרפיקה באיכות גבוהה בזמן אמת באפליקציות. יתרונות השימוש ב-Vulkan כוללים הפחתת תקורה של מעבד ותמיכה בשפת הביניים הבינארית SPIR-V .

כדי ליישם את Vulkan בהצלחה, מכשיר חייב לכלול:

  • מטעין הוולקן, מסופק על ידי אנדרואיד.
  • מנהל התקן Vulkan, מסופק על ידי SoCs כגון GPU IHVs, שמיישם את Vulkan API . כדי לתמוך בפונקציונליות של Vulkan, מכשיר האנדרואיד זקוק לחומרת GPU התומכת ב-Vulkan ואת מנהל ההתקן המשויך. ה-GPU חייב לתמוך גם ב-GLES 3.1 ומעלה. התייעץ עם ספק ה-SoC שלך כדי לבקש תמיכה בנהגים.

אם התקן כולל מנהל התקן Vulkan, המכשיר צריך להצהיר על תכונות מערכת FEATURE_VULKAN_HARDWARE_LEVEL ו- FEATURE_VULKAN_HARDWARE_VERSION , עם גרסאות המשקפות במדויק את יכולות המכשיר. זה עוזר להבטיח שהמכשיר תואם למסמך הגדרת התאימות (CDD).

מעמיס וולקן

platform/frameworks/native/vulkan היא הממשק העיקרי בין אפליקציות Vulkan לבין מנהל ההתקן של Vulkan. טוען Vulkan מותקן ב- /system/lib[64]/libvulkan.so . המטען מספק את נקודות הכניסה הליבה של Vulkan API, את נקודות הכניסה של הרחבות הנדרשות על ידי ה-CDD של Android, והרחבות אופציונליות רבות נוספות. הרחבות של שילוב מערכת חלונות (WSI) מיוצאות על ידי המטען ומיושמות בעיקר במטען ולא במנהל ההתקן. המעמיס תומך גם בספירה וטעינה של שכבות שיכולות לחשוף הרחבות נוספות וליירט קריאות ליבה של API בדרכן למנהל ההתקן.

ה-NDK כולל ספריית stub libvulkan.so לקישור. הספרייה מייצאת את אותם סמלים כמו המטען. אפליקציות מתקשרות לפונקציות המיוצאות מספריית libvulkan.so האמיתית כדי להזין פונקציות טרמפולינה בטוען, שנשלחות לשכבה או למנהל ההתקן המתאים בהתבסס על הארגומנט הראשון שלהן. הקריאה vkGet*ProcAddr() מחזירה את מצביעי הפונקציות שאליהם שולחות הטרמפולינות (כלומר, היא קוראת ישירות לקוד ה-API הליבה). קריאה דרך מצביעי הפונקציות, במקום הסמלים המיוצאים, יעילה יותר מכיוון שהיא מדלגת על הטרמפולינה והמשלוח.

ספירת נהגים וטעינה

כאשר תמונת המערכת נבנית, אנדרואיד מצפה מהמערכת לדעת אילו GPUs זמינים. המטען משתמש במנגנון HAL הקיים ב- hardware.h כדי לגלות ולטעון את מנהל ההתקן. נתיבים מועדפים עבור מנהלי התקנים של וולקן של 32 סיביות ו-64 סיביות הם:

/vendor/lib/hw/vulkan.<ro.hardware.vulkan>.so
/vendor/lib/hw/vulkan.<ro.product.platform>.so
/vendor/lib64/hw/vulkan.<ro.hardware.vulkan>.so
/vendor/lib64/hw/vulkan.<ro.product.platform>.so

באנדרואיד 7.0 ואילך, נגזרת hw_module_t של Vulkan עוטפת מבנה hw_module_t יחיד; רק מנהל התקן אחד נתמך והמחרוזת הקבועה HWVULKAN_DEVICE_0 מועברת ל- open() .

נגזרת Vulkan hw_device_t מתאימה למנהל התקן בודד שיכול לתמוך במספר מכשירים פיזיים. מבנה hw_device_t יכול להרחיב לייצא vkGetGlobalExtensionProperties() , vkCreateInstance() ו- vkGetInstanceProcAddr() . המטען יכול למצוא את כל שאר VkInstance() , VkPhysicalDevice() ו- vkGetDeviceProcAddr() על ידי קריאה hw_device_t vkGetInstanceProcAddr() של מבנה hw_device_t.

גילוי וטעינה של שכבות

מטעין ה-Vulkan תומך בספירה וטעינה של שכבות שיכולות לחשוף הרחבות נוספות וליירט קריאות ליבה ל-API בדרכן אל הדרייבר. אנדרואיד לא כולל שכבות בתמונת המערכת; עם זאת, אפליקציות עשויות לכלול שכבות ב-APK שלהן.

בעת שימוש בשכבות, זכור שמודל האבטחה ומדיניות האבטחה של אנדרואיד שונים באופן משמעותי מפלטפורמות אחרות. בפרט, אנדרואיד לא מאפשרת טעינת קוד חיצוני לתהליך שאינו ניתן לתיקון באגים במכשירי ייצור (לא שורשיים), וגם לא מאפשרת לקוד חיצוני לבדוק או לשלוט בזיכרון, מצב התהליך וכן הלאה. זה כולל איסור על שמירת dump הליבה, עקבות API וכן הלאה לדיסק לבדיקה מאוחרת יותר. רק שכבות המסופקות כחלק מאפליקציות שאינן ניתנות לתיקון באגים מופעלות במכשירי ייצור, ואסור למנהלי התקנים לספק פונקציונליות שמפרה מדיניות זו.

מקרי שימוש לשכבות כוללים:

  • שכבות זמן פיתוח - אין להתקין שכבות אימות ושימס עבור כלי מעקב/פרופילים/ניפוי באגים בתמונת המערכת של התקני ייצור. שכבות אימות ו-shims עבור כלי מעקב/פרופילים/ניפוי באגים צריכים להיות ניתנים לעדכון ללא תמונת מערכת. מפתחים שרוצים להשתמש באחת מהשכבות הללו במהלך הפיתוח יכולים לשנות את חבילת האפליקציה, למשל, על ידי הוספת קובץ לספריית הספריות המקוריות שלהם. מהנדסי IHV ו-OEM שרוצים לאבחן כשלים במשלוח של אפליקציות שאינן ניתנות לשינוי, מניחים שיש להם גישה לבנייה לא-ייצור (שורשית) של תמונת המערכת, אלא אם אפליקציות אלו ניתנות לניפוי באגים. למידע נוסף ראה שכבות אימות Vulkan ב-Android .
  • שכבות שירות - שכבות אלו חושפות הרחבות, כגון שכבה המיישמת מנהל זיכרון עבור זיכרון המכשיר. מפתחים בוחרים שכבות, וגרסאות של שכבות אלה, לשימוש באפליקציה שלהם; אפליקציות שונות המשתמשות באותה שכבה עדיין עשויות להשתמש בגרסאות שונות. מפתחים בוחרים איזו מהשכבות הללו לשלוח בחבילת האפליקציה שלהם.
  • שכבות מוזרקות (מרומזות) - כולל שכבות כגון קצב פריימים, רשת חברתית ושכבות-על של משגר משחקים שסופקו על ידי המשתמש או אפליקציה אחרת ללא ידיעת האפליקציה או הסכמתה. אלה מפרים את מדיניות האבטחה של Android ואינם נתמכים.

עבור אפליקציות שאינן ניתנות לתיקון באגים, הטוען מחפש שכבות רק בספריית הספרייה המקורית של האפליקציה ומנסה לטעון כל ספרייה עם שם התואם לדפוס מסוים (לדוגמה, libVKLayer_foo.so ).

עבור אפליקציות שניתנות לאיפוי באגים, הטוען מחפש שכבות ב- /data/local/debug/vulkan ומנסה לטעון כל ספרייה התואמת לדפוס מסוים.

אנדרואיד מאפשרת העברה של שכבות עם שינויים בסביבת הבנייה בין אנדרואיד לפלטפורמות אחרות. לפרטים על הממשק בין השכבות והמטען, ראה ארכיטקטורה של ממשקי ה-Vulkan Loader . שכבות האימות המתוחזקות על ידי Khronos מתארחות בשכבות אימות Vulkan .

גרסאות ויכולות של Vulkan API

הטבלה הבאה מפרטת גרסאות Vulkan API עבור מספר מהדורות אנדרואיד.
גרסת אנדרואיד גרסת וולקן
אנדרואיד 13 וולקן 1.3
אנדרואיד 9 וולקן 1.1
אנדרואיד 7 וולקן 1.0

סקירת פונקציונליות של Vulkan 1.3

Vulkan 1.3 מקנון מספר הרחבות אופציונליות בעבר לפונקציונליות הליבה של Vulkan. חלק גדול מהפונקציונליות הזו נכלל במטרה להגביר את השליטה והפירוט בממשק התכנות של Vulkan. מופעי העברת רינדור במעבר יחיד אינם צריכים עוד אובייקטי העברת רינדור או מאגרי מסגרות. ניתן לצמצם את המספר הכולל של אובייקטי מצב צינור, והסנכרון בתוך ה-API עובר שיפוץ. ל-Vulkan 1.3 יש אותן דרישות חומרה כמו ל-Vulkan 1.2, 1.1 ו-1.0, כאשר רוב המימוש במנהל ההתקן הגרפי הספציפי ל-SoC, לא במסגרת.

התכונות החשובות ביותר של Vulkan 1.3 עבור אנדרואיד הן:

  • תמיכה במופעי רינדור במעבר יחיד
  • תמיכה לסיום מיידי של קריאת הצללה
  • פירוט עדין יותר על פני יצירה, שיתוף ושליטה בצנרת

Vulkan 1.3 כולל גם כמה תכונות קטנות יותר ושיפורי שימושיות API. כל השינויים שבוצעו ב-Vulkan API הליבה עם גרסה מינורית 1.3 ניתן למצוא ב- Core Revisions (Vulkan 1.3) .

סקירת פונקציונליות של Vulkan 1.2

Vulkan 1.2 מוסיף מספר תכונות והרחבות המפשטות את משטח ה-API. זה כולל מודל זיכרון מאוחד ומידע נוסף שניתן לשאול מנהל התקן. ל-Vulkan 1.2 יש אותן דרישות חומרה כמו ל-Vulkan 1.0 ו-1.1; כל היישום הוא במנהל ההתקן הגרפי הספציפי ל-SoC, לא במסגרת.

התכונה החשובה ביותר של Vulkan 1.2 עבור אנדרואיד היא תמיכה באחסון 8 סיביות.

Vulkan 1.2 כולל גם כמה תכונות קטנות יותר ושיפורי שימושיות API. ניתן למצוא את כל השינויים שבוצעו ב-Vulkan API הליבה עם גרסה מינורית 1.2 ב- Core Revisions (Vulkan 1.2) .

סקירת פונקציונליות Vulkan 1.1

Vulkan 1.1 כולל תמיכה באינטררופ זיכרון/סנכרון, המאפשר ליצרני OEM לתמוך ב-Vulkan 1.1 במכשירים. בנוסף, אינטראפ זיכרון/סנכרון מאפשר למפתחים לקבוע אם Vulkan 1.1 נתמך במכשיר, ולהשתמש בו בצורה יעילה כאשר כן. ל-Vulkan 1.1 יש אותן דרישות חומרה כמו ל-Vulkan 1.0, אך רוב המימוש הוא במנהל ההתקן הגרפי הספציפי ל-SOC, לא במסגרת.

התכונות החשובות ביותר של Vulkan 1.1 עבור אנדרואיד הן:

  • תמיכה בייבוא ​​וייצוא מאגרי זיכרון וחפצי סנכרון מחוץ לוולקן (לאינטררופ עם מצלמה, קודקים ו-GLES)
  • תמיכה בפורמטים של YCbCr

Vulkan 1.1 כולל גם כמה תכונות קטנות יותר ושיפורי שימושיות API. ניתן למצוא את כל השינויים שבוצעו ב-Vulkan API הליבה עם גרסה מינורית 1.1 ב- Core Revisions (Vulkan 1.1) .

בחירת תמיכה בוולקן

מכשירי אנדרואיד צריכים לתמוך בערכת התכונות המתקדמת ביותר של Vulkan הקיימת, בתנאי שהם תומכים ב- ABI של 64 סיביות ושאין להם זיכרון נמוך.

מכשירים המופעלים עם אנדרואיד 13 ומעלה צריכים לתמוך ב-Vulkan 1.3.

מכשירים המופעלים דרך אנדרואיד 10 צריכים לתמוך ב-Vulkan 1.1.

מכשירים אחרים יכולים לתמוך באופן אופציונלי ב-Vulkan 1.3, 1.2 ו-1.1.

תמיכה בגרסת וולקן

מכשיר אנדרואיד תומך בגרסת Vulkan אם מתקיימים התנאים הבאים:

  1. הוסף מנהל התקן Vulkan התומך בגרסת ה-Vulkan של עניין (זו חייבת להיות אחת מגרסת Vulkan 1.3, 1.1 או 1.0) לצד דרישות ה-CDD הנוספות של גרסת אנדרואיד. לחלופין, עדכן דרייבר קיים של Vulkan עם מספר גרסה נמוך יותר של vulkan.
  2. עבור Vulkan 1.3 או 1.1, ודא שתכונת המערכת המוחזרת על ידי מנהל החבילות מחזירה true עבור גרסת ה-Vulkan הנכונה.
    • עבור Vulkan 1.3 התכונה היא PackageManager#hasSystemFeature(PackageManager.FEATURE_VULKAN_HARDWARE_VERSION, 0x403000) .
    • עבור Vulkan 1.1 התכונה היא PackageManager#hasSystemFeature(PackageManager.FEATURE_VULKAN_HARDWARE_VERSION, 0x401000) .
    מנהל החבילות יחזיר true עבור Vulkan 1.3 ו-Vulkan 1.1 על ידי הוספת כלל, המוצג כדלקמן, לקובץ device.mk המתאים.
    • הוסף את הדברים הבאים עבור Vulkan 1.3:
      PRODUCT_COPY_FILES += frameworks/native/data/etc/android.hardware.vulkan.version-1_3.xml:
      $(TARGET_COPY_OUT_VENDOR)/etc/permissions/android.hardware.vulkan.version.xml
      
    • הוסף את הדברים הבאים עבור Vulkan 1.1:
      PRODUCT_COPY_FILES += frameworks/native/data/etc/android.hardware.vulkan.version-1_1.xml:
      $(TARGET_COPY_OUT_VENDOR)/etc/permissions/android.hardware.vulkan.version.xml
      

שילוב מערכת חלונות (WSI)

ב- libvulkan.so , מנהל ההתקן מיישם את ההרחבות הבאות של Window System Integration (WSI):

  • VK_KHR_surface
  • VK_KHR_android_surface
  • VK_KHR_swapchain
  • VK_KHR_driver_properties , מיושם עבור Vulkan 1.1 באנדרואיד 10 בלבד
  • VK_GOOGLE_display_timing , מיושם עבור כל גרסת וולקן באנדרואיד 10

האובייקטים VkSurfaceKHR ו- VkSwapchainKHR וכל האינטראקציות עם ANativeWindow מטופלים על ידי הפלטפורמה ואינם חשופים למנהלי התקנים. הטמעת WSI מסתמכת על תוסף VK_ANDROID_native_buffer , אשר חייב להיות נתמך על ידי מנהל ההתקן; תוסף זה נמצא בשימוש רק על ידי יישום WSI ואינו חשוף לאפליקציות.

דגלי שימוש של Gralloc

מימושים של Vulkan עשויים להזדקק למאגרי swapchain שיוקצו עם דגלי שימוש פרטיים המוגדרים ביישום Gralloc. בעת יצירת swapchain, אנדרואיד מבקש מהנהג לתרגם את דגלי השימוש בפורמט ובתמונות לדגלי השימוש של Gralloc על ידי קריאה:

typedef enum VkSwapchainImageUsageFlagBitsANDROID {
    VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID = 0x00000001,
    VK_SWAPCHAIN_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkSwapchainImageUsageFlagBitsANDROID;
typedef VkFlags VkSwapchainImageUsageFlagsANDROID;

VkResult VKAPI vkGetSwapchainGrallocUsage2ANDROID(
    VkDevice                          device,
    VkFormat                          format,
    VkImageUsageFlags                 imageUsage,
    VkSwapchainImageUsageFlagsANDROID swapchainUsage,
    uint64_t*                         grallocConsumerUsage,
    uint64_t*                         grallocProducerUsage
);

הפרמטרים של format וה- imageUsage לקוחים ממבנה VkSwapchainCreateInfoKHR . מנהל ההתקן צריך למלא *grallocConsumerUsage ו- *grallocProducerUsage בדגלי השימוש של Gralloc הנדרשים עבור הפורמט והשימוש. דגלי השימוש המוחזרים על ידי הנהג משולבים עם דגלי השימוש המבוקש על ידי צרכן ה-swapchain בעת הקצאת מאגרים.

אנדרואיד 7.x קורא לגרסה קודמת של VkSwapchainImageUsageFlagsANDROID() , בשם vkGetSwapchainGrallocUsageANDROID() . אנדרואיד 8.0 ומעלה מוציאה משימוש vkGetSwapchainGrallocUsageANDROID() אך עדיין קורא vkGetSwapchainGrallocUsageANDROID() אם vkGetSwapchainGrallocUsage2ANDROID() אינו מסופק על ידי מנהל ההתקן:

VkResult VKAPI vkGetSwapchainGrallocUsageANDROID(
    VkDevice            device,
    VkFormat            format,
    VkImageUsageFlags   imageUsage,
    int*                grallocUsage
);

vkGetSwapchainGrallocUsageANDROID() אינו תומך בדגלי שימוש ב-swapchain או בדגלי שימוש מורחבים של Gralloc.

תמונות מגובות Gralloc

VkNativeBufferANDROID הוא מבנה הרחבה vkCreateImage ליצירת תמונה מגובה במאגר Gralloc. VkNativeBufferANDROID מסופק ל- vkCreateImage() בשרשרת המבנה של VkImageCreateInfo . קריאות ל- vkCreateImage() עם VkNativeBufferANDROID מתרחשות במהלך הקריאה ל- vkCreateSwapchainKHR . יישום WSI מקצה את מספר המאגרים המקוריים המבוקש עבור ה-swapchain, ולאחר מכן יוצר VkImage עבור כל אחד מהם:

typedef struct {
    VkStructureType             sType; // must be VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID
    const void*                 pNext;

    // Buffer handle and stride returned from gralloc alloc()
    buffer_handle_t             handle;
    int                         stride;

    // Gralloc format and usage requested when the buffer was allocated.
    int                         format;
    int                         usage;
    // Beginning in Android 8.0, the usage field above is deprecated and the
    // usage2 struct below was added. The usage field is still filled in for
    // compatibility with Android 7.0 drivers. Drivers for Android 8.0
    // should prefer the usage2 struct, especially if the
    // android.hardware.graphics.allocator HAL uses the extended usage bits.
    struct {
        uint64_t                consumer;
        uint64_t                producer;
    } usage2;
} VkNativeBufferANDROID;

בעת יצירת תמונה מגובה Gralloc, ל- VkImageCreateInfo יש את הנתונים הבאים:

  .sType               = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO
  .pNext               = the above VkNativeBufferANDROID structure
  .imageType           = VK_IMAGE_TYPE_2D
  .format              = a VkFormat matching the format requested for the gralloc buffer
  .extent              = the 2D dimensions requested for the gralloc buffer
  .mipLevels           = 1
  .arraySize           = 1
  .samples             = 1
  .tiling              = VK_IMAGE_TILING_OPTIMAL
  .usage               = VkSwapchainCreateInfoKHR::imageUsage
  .flags               = 0
  .sharingMode         = VkSwapchainCreateInfoKHR::imageSharingMode
  .queueFamilyCount    = VkSwapchainCreateInfoKHR::queueFamilyIndexCount
  .pQueueFamilyIndices = VkSwapchainCreateInfoKHR::pQueueFamilyIndices

באנדרואיד 8.0 ומעלה, הפלטפורמה מספקת מבנה סיומת VkSwapchainImageCreateInfoKHR בשרשרת VkImageCreateInfo המסופקת ל- vkCreateImage כאשר נדרשים דגלי שימוש בתמונת swapchain עבור ה-swapchain. מבנה ההרחבה מכיל את דגלי השימוש בתמונות swapchain:

typedef struct {
    VkStructureType                        sType; // must be VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID
    const void*                            pNext;

    VkSwapchainImageUsageFlagsANDROID      usage;
} VkSwapchainImageCreateInfoANDROID;

באנדרואיד 10 ומעלה, הפלטפורמה תומכת ב- VK_KHR_swapchain v70, כך שהאפליקציה Vulkan מסוגלת ליצור VkImage מגובה בזיכרון swapchain. האפליקציה קוראת תחילה ל- vkCreateImage עם מבנה VkImageSwapchainCreateInfoKHR המשורשר למבנה VkImageCreateInfo . לאחר מכן, האפליקציה קוראת ל- vkBindImageMemory2(KHR) עם מבנה VkBindImageMemorySwapchainInfoKHR המשורשר למבנה VkBindImageMemoryInfo . ה- imageIndex שצוין במבנה VkBindImageMemorySwapchainInfoKHR חייב להיות אינדקס תמונת swapchain חוקי. בינתיים, הפלטפורמה מספקת מבנה סיומת VkNativeBufferANDROID עם מידע המאגר התואם של VkBindImageMemoryInfo לשרשרת VkBindImageMemoryInfo, כך שהנהג יודע לאיזה מאגר Gralloc לקשור את ה- VkImage .

רכישת תמונות

vkAcquireImageANDROID רוכש בעלות על תמונת swapchain ומייבא גדר מקורית עם איתות חיצוני הן לאובייקט VkSemaphore קיים והן לאובייקט VkFence קיים:

VkResult VKAPI vkAcquireImageANDROID(
    VkDevice            device,
    VkImage             image,
    int                 nativeFenceFd,
    VkSemaphore         semaphore,
    VkFence             fence
);

vkAcquireImageANDROID() נקרא במהלך vkAcquireNextImageKHR כדי לייבא גדר מקורית לאובייקטים VkSemaphore ו- VkFence המסופקים על ידי האפליקציה (עם זאת, אובייקטי סמפור וגם גדר הם אופציונליים בקריאה זו). מנהל ההתקן עשוי גם להשתמש בהזדמנות זו כדי לזהות ולטפל בכל שינוי חיצוני במצב המאגר של Gralloc; נהגים רבים לא יצטרכו לעשות כאן שום דבר. קריאה זו מכניסה את VkSemaphore ו- VkFence לאותו מצב בהמתנה כאילו אותתה על ידי vkQueueSubmit , כך שתורים יכולים לחכות על הסמפור והאפליקציה יכולה לחכות על הגדר.

שני העצמים מקבלים איתות כאשר הגדר המקומית הבסיסית מאותתת; אם הגדר המקורית כבר סימנה, אז הסמפור נמצא במצב המסומן כאשר הפונקציה הזו חוזרת. הנהג לוקח בעלות על מתאר קובץ הגדר וסוגר את מתאר קובץ הגדר כאשר אין צורך יותר. הנהג חייב לעשות זאת גם אם לא מסופק אובייקט סמפור או גדר, או אפילו אם vkAcquireImageANDROID נכשל ומחזיר שגיאה. אם fenceFd הוא -1, זה כאילו הגדר המקורית כבר אותתה.

שחרור תמונות

vkQueueSignalReleaseImageANDROID מכין תמונת swapchain לשימוש חיצוני, יוצר גדר מקורית ומתזמן את הגדר המקורית לאותת לאחר שסמאפורות הקלט סימנו:

VkResult VKAPI vkQueueSignalReleaseImageANDROID(
    VkQueue             queue,
    uint32_t            waitSemaphoreCount,
    const VkSemaphore*  pWaitSemaphores,
    VkImage             image,
    int*                pNativeFenceFd
);

vkQueuePresentKHR() קורא vkQueueSignalReleaseImageANDROID() בתור שסופק. על הנהג לייצר גדר מקורית שאינה מאותתת עד שכל waitSemaphoreCount של pWaitSemaphores באות pWaitSemaphores, וכל עבודה נוספת הנדרשת להכנת image למצגת מסתיימת.

אם סמפורות ההמתנה (אם יש כאלה) כבר סימנו, queue כבר לא פעיל, הנהג יכול להגדיר את *pNativeFenceFd ל -1 במקום מתאר קובץ גדר מקורי, מה שמציין שאין למה לחכות. המתקשר הוא הבעלים של מתאר הקובץ שהוחזר ב- *pNativeFenceFd .

מנהלי התקנים רבים יכולים להתעלם מפרמטר התמונה, אך ייתכן שחלקם יצטרכו להכין מבני נתונים בצד המעבד המשויכים למאגר Gralloc לשימוש על ידי צרכני תמונה חיצוניים. הכנת תוכן מאגר לשימוש על ידי צרכנים חיצוניים צריכה להיעשות באופן אסינכרוני כחלק מהמעבר של התמונה ל- VK_IMAGE_LAYOUT_PRESENT_SRC_KHR .

אם התמונה נוצרה עם VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID , על מנהל ההתקן לאפשר vkQueueSignalReleaseImageANDROID() להיקרא שוב ושוב ללא קריאות מתערבות ל- vkAcquireImageANDROID() .

תמיכה בתמונה ייצוגית משותפת

חלק מהמכשירים יכולים לחלוק בעלות על תמונה בודדת בין צינור התצוגה והיישום של Vulkan כדי למזער את זמן ההשהיה. באנדרואיד 9 ומעלה, המטען מפרסם באופן מותנה את התוסף VK_KHR_shared_presentable_image בהתבסס על תגובת הנהג לקריאה אל vkGetPhysicalDeviceProperties2 .

אם מנהל ההתקן אינו תומך ב-Vulkan 1.1 או בתוסף VK_KHR_physical_device_properties2 , המטען אינו מפרסם תמיכה בתמונות משותפות שניתן להציג. אחרת, הטוען שואל את יכולות הדרייבר על ידי קריאה vkGetPhysicalDeviceProperties2() ולכלול את המבנה הבא בשרשרת VkPhysicalDeviceProperties2::pNext :

typedef struct {
    VkStructureType sType; // must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID
    const void*     pNext;
    VkBool32        sharedImage;
} VkPhysicalDevicePresentationPropertiesANDROID;

אם הנהג יכול לחלוק בעלות על תמונה עם מערכת התצוגה, הוא מגדיר את חבר sharedImage ל- VK_TRUE .

מַתַן תוֹקֵף

יצרני OEM יכולים לבדוק את יישום ה-Vulkan שלהם באמצעות CTS, הכולל את הדברים הבאים:

  • בדיקות Khronos Vulkan Conformance במודול CtsDeqpTestCases , הכוללות בדיקות API פונקציונליות עבור Vulkan 1.0, 1.1, 1.2 ו-1.3.
  • מודול CtsGraphicsTestCases , שבודק שהמכשיר מוגדר כהלכה ליכולות הוולקן בהן הוא תומך.

דגל תכונת וולקן

מכשיר התומך ב-Android 11 ומעלה ותומך ב-Vulkan API נדרש לחשוף דגל תכונה, android.software.vulkan.deqp.level . הערך של דגל תכונה זה הוא תאריך, המקודד כערך מספר שלם. הוא מציין את התאריך המשויך לבדיקות Vulkan dEQP שהמכשיר טוען שהוא עובר.

תאריך בצורת YYYY-MM-DD מקודד כמספר שלם של 32 סיביות באופן הבא:

  • Bits 0-15 מאחסן את השנה
  • Bits 16-23 מאחסנים את החודש
  • Bits 24-31 מאחסן את היום

הערך המינימלי המותר לדגל התכונה הוא 0x07E30301 , המתאים לתאריך 2019-03-01, שהוא התאריך המשויך למבחני Vulkan dEQP עבור אנדרואיד 10. אם דגל התכונה הוא לפחות ערך זה, המכשיר טוען לעבור את כל מבחני אנדרואיד 10 Vulkan dEQP.

ערך 0x07E40301 מתאים לתאריך 2020-03-01, שהוא התאריך המשויך למבחני Vulkan dEQP עבור אנדרואיד 11. אם דגל הפיצ'ר הוא לפחות ערך זה, המכשיר טוען שהוא עובר את כל מבחני אנדרואיד 11 Vulkan dEQP.

ערך 0x07E60301 מתאים לתאריך 2022-03-01, שהוא התאריך המשויך למבחני Vulkan dEQP עבור אנדרואיד 13. אם דגל התכונה הוא לפחות ערך זה, המכשיר טוען שהוא עובר את כל מבחני אנדרואיד 13 Vulkan dEQP.

מכשיר שחושף דגל תכונה ספציפי ( כלומר 0x07E30301 , 0x07E40301 , 0x07E60301 ) טוען שהוא עובר את כל מבחני אנדרואיד Vulkan dEQP של דגל תכונה זה (אנדרואיד 10, אנדרואיד 11, אנדרואיד 13 בהתאמה). מכשיר זה עשוי לעבור בדיקות Vulkan dEQP מגרסה מאוחרת יותר של אנדרואיד.

Vulkan dEQP מהווה חלק מ-Android CTS. מאנדרואיד 11, רכיב רץ המבחן dEQP של CTS מודע לדגל התכונה android.software.vulkan.deqp.level , ומדלג על כל בדיקות Vulkan dEQP שבהן - לפי דגל תכונה זה - המכשיר אינו מתיימר לתמוך. מבחנים כאלה מדווחים כעמידים באופן טריוויאלי.