บล็อกหน่วยความจำ HIDL

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

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

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

• การใช้ per hidl_memory สำหรับการจัดสรรบัฟเฟอร์แต่ละครั้งจะมีค่าเฉลี่ยการจัดสรร 238 us/1
• การใช้ MemoryBlock และการแบ่งปัน hidl_memory เดียวจะมีค่าเฉลี่ยการจัดสรร 2.82 us/1

สถาปัตยกรรม

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

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

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

ในส่วนนี้จะแสดงตัวอย่างการใช้ 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 ของมันได้รับการแมปและเป็น munmap() -ed เมื่อไม่มีการอ้างถึงมัน เพื่อให้ hidl_memory แมปอยู่เสมอ คุณสามารถใช้ lockMemory ซึ่งเป็นอ็อบเจ็กต์สไตล์ RAII ที่จะเก็บ hidl_memory ที่สอดคล้องกันตลอดวงจรชีวิตการล็อค ตัวอย่าง:

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

ขยายการใช้งาน

ส่วนนี้ให้รายละเอียดเกี่ยวกับการใช้งาน MemoryBlock แบบขยาย

การใช้จำนวนอ้างอิงเพื่อจัดการ Memoryblock

ในสถานการณ์ส่วนใหญ่ วิธีที่มีประสิทธิภาพที่สุดในการใช้ MemoryBlock คือการจัดสรร/จัดสรรคืนอย่างชัดเจน อย่างไรก็ตาม ในแอปพลิเคชันที่ซับซ้อนที่ใช้จำนวนอ้างอิงสำหรับการรวบรวมขยะอาจเป็นแนวคิดที่ดีกว่า หากต้องการนับการอ้างอิงบน MemoryBlock คุณสามารถผูก MemoryBlock กับวัตถุ Binder ซึ่งช่วยในการนับการอ้างอิงและจัดสรรคืน 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 โดยใช้ Memory Dealer ตัวอย่าง:

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