MemoryBlock של HIDL

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

שיפורי ביצועים

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

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

ארכיטקטורה

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

MemoryBlock של HIDL

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

שימוש רגיל

בקטע הזה נספק דוגמה לשימוש ב-MemoryBlock, תחילה בהצהרה על ה-HAL ולאחר מכן בהטמעת ה-HAL.

הצהרת ה-HAL

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

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, שהוא מבנה (struct) שמוגדר באמצעות 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() בפעם הראשונה שאחד מה-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 לאובייקט קישור, וכך לספור את ההפניות ולהקצות להן את MemoryBlock כשהמספר יורד לאפס.

הצהרה על HAL

כשמגדירים את ה-HAL, מתארים מבנה HIDL שמכיל מופע של MemoryBlock ו-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(...);