HIDL MemoryBlock

‫HIDL MemoryBlock היא שכבה מופשטת שמבוססת על hidl_memory,‏ HIDL @1.0::IAllocator ו-HIDL @1.0::IMapper. הוא מיועד לשירותי HIDL שיש להם כמה בלוקים של זיכרון שמשתפים ערימת זיכרון אחת.

שיפרנו את הביצועים.

שימוש ב-MemoryBlock באפליקציות יכול להפחית באופן משמעותי את מספר השגיאות של פילוח מרחב המשתמשים mmap/munmap, וכך לשפר את הביצועים. לדוגמה:

• השימוש ב-per hidl_memory לכל הקצאת מאגר מסתכם בממוצע ב-238 מיקרו-שניות לכל הקצאה.
• שימוש ב-MemoryBlock ושיתוף של hidl_memory אחד בממוצע של 2.82 מיקרו-שניות לכל הקצאה.

ארכיטקטורה

ארכיטקטורת HIDL MemoryBlock כוללת שירותי HIDL עם כמה בלוקים של זיכרון שמשתפים ערימת זיכרון אחת:

איור 1. ארכיטקטורת HIDL MemoryBlock

שימוש רגיל

בקטע הזה מופיעה דוגמה לשימוש ב-MemoryBlock. בדוגמה הזו, קודם מצהירים על HAL ואז מיישמים אותו.

הצהרה על HAL

בדוגמה הבאה של IFoo HAL:

import android.hidl.memory.block@1.0::MemoryBlock;

interface IFoo {
    getSome() generates(MemoryBlock block);
    giveBack(MemoryBlock block);
};

הפורמט של Android.bp הוא:

hidl_interface {
    ...
    srcs: [
        "IFoo.hal",
    ],
    interfaces: [
        "android.hidl.memory.block@1.0",
        ...
};

הטמעה של HAL

כדי להטמיע את ה-HAL לדוגמה:

1. קבלת hidl_memory (פרטים נוספים זמינים במאמר בנושא HIDL C++‎).

   #include <android/hidl/allocator/1.0/IAllocator.h>
   
   using ::android::hidl::allocator::V1_0::IAllocator;
   using ::android::hardware::hidl_memory;
   ...
     sp<IAllocator> allocator = IAllocator::getService("ashmem");
     allocator->allocate(2048, [&](bool success, const hidl_memory& mem)
     {
           if (!success) { /* error */ }
           // you can now use the hidl_memory object 'mem' or pass it
     }));
   

2. יוצרים מכונת HidlMemoryDealer עם hidl_memory שנרכש:

   #include <hidlmemory/HidlMemoryDealer.h>
   
   using ::android::hardware::HidlMemoryDealer
   /* The mem argument is acquired in the Step1, returned by the ashmemAllocator->allocate */
   sp<HidlMemoryDealer> memory_dealer = HidlMemoryDealer::getInstance(mem);
   

3. מקצים MemoryBlock, שהוא מבנה שמוגדר באמצעות HIDL.

   דוגמה MemoryBlock:

   struct MemoryBlock {
   IMemoryToken token;
   uint64_t size;
   uint64_t offset;
   };
   

   דוגמה לשימוש ב-MemoryDealer כדי להקצות MemoryBlock:

   #include <android/hidl/memory/block/1.0/types.h>
   
   using ::android::hidl::memory::block::V1_0::MemoryBlock;
   
   Return<void> Foo::getSome(getSome_cb _hidl_cb) {
       MemoryBlock block = memory_dealer->allocate(1024);
       if(HidlMemoryDealer::isOk(block)){
           _hidl_cb(block);
       ...
   

4. ביטול ההקצאה של MemoryBlock:

   Return<void> Foo::giveBack(const MemoryBlock& block) {
       memory_dealer->deallocate(block.offset);
   ...
   

5. מבצעים שינויים בנתונים:

   #include <hidlmemory/mapping.h>
   #include <android/hidl/memory/1.0/IMemory.h>
   
   using ::android::hidl::memory::V1_0::IMemory;
   
   sp<IMemory> memory = mapMemory(block);
   uint8_t* data =
   
   static_cast<uint8_t*>(static_cast<void*>(memory->getPointer()));
   

6. הגדרות Android.bp:

   shared_libs: [
           "android.hidl.memory@1.0",
   
           "android.hidl.memory.block@1.0"
   
           "android.hidl.memory.token@1.0",
           "libhidlbase",
           "libhidlmemory",
   

7. בודקים את התהליך כדי לדעת אם צריך lockMemory.

   בדרך כלל, MemoryBlock משתמש בספירת הפניות כדי לשמור את hidl_memory המשותף mmap()-ed בפעם הראשונה שאחד מהם MemoryBlock instances is mapped and ismunmap()‎-ed when nothing refers to it. To keephidl_memoryalways mapped, you can uselockMemory, a RAII style object that keeps the correspondinghidl_memory` ממופה לאורך מחזור החיים של הנעילה. דוגמה:

   #include <hidlmemory/mapping.h>
   
   sp<RefBase> lockMemory(const sp<IMemoryToken> key);
   

שימוש מורחב

בקטע הזה מפורט השימוש המורחב ב-MemoryBlock.

שימוש בספירת הפניות לניהול MemoryBlock

ברוב המקרים, הדרך היעילה ביותר להשתמש ב-MemoryBlock היא להקצות או לבטל הקצאה באופן מפורש. עם זאת, באפליקציות מורכבות שמשתמשות בספירת הפניות, יכול להיות שיהיה עדיף להשתמש באיסוף אשפה. כדי לקבל ספירת הפניות ב-MemoryBlock, אפשר לקשר את MemoryBlock לאובייקט binder, שעוזר לספור את ההפניות ולבטל את ההקצאה של MemoryBlock כשהספירה יורדת לאפס.

הצהרה על HAL

כשמצהירים על HAL, מתארים מבנה HIDL שמכיל MemoryBlock instance ו-IBase:

import android.hidl.memory.block@1.0::MemoryBlock;

struct MemoryBlockAllocation {
    MemoryBlock block;
    IBase refcnt;
};

משתמשים ב-MemoryBlockAllocation כדי להחליף את MemoryBlock ולהסיר את השיטה כדי להחזיר את MemoryBlock. הזיכרון מבוטל על ידי ספירת הפניות באמצעות MemoryBlockAllocation. דוגמה:

interface IFoo {
    allocateSome() generates(MemoryBlockAllocation allocation);
};

הטמעה של HAL

דוגמה להטמעה בצד השרת של HAL:

class MemoryBlockRefCnt: public virtual IBase {
   MemoryBlockRefCnt(uint64_t offset, sp<MemoryDealer> dealer)
     : mOffset(offset), mDealer(dealer) {}
   ~MemoryBlockRefCnt() {
       mDealer->deallocate(mOffset);
   }
 private:
   uint64_t mOffset;
   sp<MemoryDealer> mDealer;
};

Return<void> Foo::allocateSome(allocateSome_cb _hidl_cb) {
    MemoryBlockAllocation allocation;
    allocation.block = memory_dealer->allocate(1024);
    if(HidlMemoryDealer::isOk(block)){
        allocation.refcnt= new MemoryBlockRefCnt(...);
        _hidl_cb(allocation);

דוגמה להטמעה של HAL בצד הלקוח:

ifoo->allocateSome([&](const MemoryBlockAllocation& allocation){
    ...
);

צירוף ואחזור של מטא-נתונים

כדי לקשר אפליקציות מסוימות ל-MemoryBlock שהוקצה, צריך להוסיף נתונים. אפשר להוסיף מטא-נתונים ולאחזר אותם בשתי שיטות:

• אם האפליקציה ניגשת למטא-נתונים בתדירות שבה היא ניגשת לבלוק עצמו, צריך לצרף את המטא-נתונים ולהעביר את כולם במבנה. דוגמה:

  import android.hidl.memory.block@1.0::MemoryBlock;
  
  struct MemoryBlockWithMetaData{
      MemoryBlock block;
      MetaDataStruct metaData;
  };
  

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

  import android.hidl.memory.block@1.0::MemoryBlock;
  
  struct MemoryBlockWithMetaData{
      MemoryBlock block;
      IMetaData metaData;
  };
  

  לאחר מכן, מקשרים את המטא-נתונים ל-MemoryBlock באמצעות MemoryDealer. דוגמה:

  MemoryBlockWithMetaData memory_block;
  memory_block.block = dealer->allocate(size);
  if(HidlMemoryDealer::isOk(block)){
      memory_block.metaData = new MetaData(...);