HIDL MemoryBlock

MemoryBlock ของ HIDL คือเลเยอร์นามธรรมที่สร้างขึ้นบน hidl_memory, HIDL @1.0::IAllocator และ HIDL @1.0::IMapper ซึ่งออกแบบมาสำหรับบริการ HIDL ที่มีบล็อกหน่วยความจำหลายรายการเพื่อแชร์ฮีปหน่วยความจำเดียว

ปรับปรุงประสิทธิภาพ

การใช้ MemoryBlock ในแอปสามารถลดจำนวน mmap/munmap และข้อผิดพลาดในการแบ่งส่วนพื้นที่ผู้ใช้ได้อย่างมาก ซึ่งจะช่วยปรับปรุงประสิทธิภาพ เช่น

• การใช้ hidl_memory ต่อการจัดสรรบัฟเฟอร์แต่ละรายการใช้เวลาเฉลี่ย 238 ไมโครวินาที/การจัดสรร 1 รายการ
• การใช้ MemoryBlock และการแชร์ hidl_memory รายการเดียวใช้เวลาเฉลี่ย 2.82 ไมโครวินาที/การจัดสรร 1 รายการ

สถาปัตยกรรม

สถาปัตยกรรม MemoryBlock ของ HIDL ประกอบด้วยบริการ HIDL ที่มีบล็อกหน่วยความจำหลายรายการที่แชร์ฮีปหน่วยความจำเดียว ดังนี้

รูปที่ 1 สถาปัตยกรรม MemoryBlock ของ HIDL

การใช้งานปกติ

ส่วนนี้แสดงตัวอย่างการใช้ MemoryBlock โดยประกาศ HAL ก่อน แล้วจึงติดตั้งใช้งาน 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 เมื่อจำนวนลดลงเหลือ 0

ประกาศ 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 ที่จัดสรร คุณสามารถเพิ่มและดึงข้อมูลเมตาได้โดยใช้ 2 วิธีต่อไปนี้

• หากแอปเข้าถึงข้อมูลเมตาบ่อยเท่ากับบล็อกเอง ให้เพิ่มข้อมูลเมตาและส่งข้อมูลทั้งหมดในโครงสร้าง ตัวอย่าง

  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(...);