HIDL 内存块

HIDL MemoryBlock 是一个在 hidl_memoryHIDL @1.0::IAllocatorHIDL @1.0::IMapper 的基础上构建而成的抽象层。它专为有多个内存块共用单个内存堆的 HIDL 服务而设计。

性能提升

在应用中使用 MemoryBlock 可显著减少 mmap/munmap 数量和用户空间分段错误,从而提升性能。例如:

  • 对每个缓冲区分配使用一个 hidl_memory,则每次分配平均用时 238 微秒。
  • 使用 MemoryBlock 并共享单个 hidl_memory,则每次分配平均用时 2.82 微秒。

架构

HIDL MemoryBlock 架构包括有多个内存块共用单个内存堆的 HIDL 服务:

HIDL MemoryBlock

图 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. 使用获取的 hidl_memory 创建 HidlMemoryDealer

    #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:当其中有 MemoryBlock 首次被映射时,系统会对该内存执行 mmap() 操作;如果没有任何内容引用该内存,则系统会对其执行 munmap() 操作。为确保始终映射 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 时,请描述包含 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;
        };
        

    接下来,使用 Memory Dealer 将元数据和 MemoryBlock 绑定在一起。示例:

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