O Google tem o compromisso de promover a igualdade racial para as comunidades negras. Saiba como.

Bloco de Memória HIDL

O HIDL MemoryBlock é uma camada abstrata construída sobre hidl_memory , HIDL @1.0::IAllocator e HIDL @1.0::IMapper . Ele é projetado para serviços HIDL que têm vários blocos de memória para compartilhar um único heap de memória.

Melhorias de desempenho

Usando MemoryBlock em aplicações pode reduzir significativamente o número de mmap / munmap falhas e segmentação espaço do usuário, melhorando assim o desempenho. Por exemplo:

  • Usando per hidl_memory para cada alocação de buffer médias 238 nós / 1 alocação.
  • Usando MemoryBlock e compartilhando um único hidl_memory médias 2,82 us / 1 alocação.

Arquitetura

A arquitetura HIDL MemoryBlock inclui serviços HIDL com vários blocos de memória compartilhando um único heap de memória:

HIDL MemoryBlock

Arquitetura Figura 1. HIDL MemoryBlock

Uso normal

Esta seção fornece um exemplo de uso de MemoryBlock declarando primeiro o HAL e, em seguida, implementando o HAL.

Declarando o HAL

Para o seguinte exemplo IFoo HAL:

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

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

O Android.bp é como se segue:

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

Implementando o HAL

Para implementar o HAL de exemplo:

  1. Obter o hidl_memory (para detalhes, consulte 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. Fazer uma HidlMemoryDealer com o adquiriu 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. Alocar MemoryBlock , que é uma estrutura definida com HIDL.

    Exemplo MemoryBlock :

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

    Exemplo usando o MemoryDealer para alocar um 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. Desalocar MemoryBlock :

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

    #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. Configuração Android.bp :

    shared_libs: [
            "android.hidl.memory@1.0",
    
            "android.hidl.memory.block@1.0"
    
            "android.hidl.memory.token@1.0",
            "libhidlbase",
            "libhidlmemory",
    
  7. Comente o fluxo para determinar se você precisa lockMemory .

    Normalmente, o MemoryBlock usa a contagem de referência para manter o partilhada hidl_memory que é mmap() -ed o primeiro momento da sua MemoryBlock s é mapeado e é munmap() -ed quando nada se refere a ele. Para manter o hidl_memory sempre mapeado, você pode usar lockMemory , um objeto de estilo RAII que mantém o correspondente hidl_memory mapeados ao longo do ciclo de vida de bloqueio. Exemplo:

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

Uso prolongado

Esta seção fornece detalhes sobre o uso prolongado de MemoryBlock .

Usando contagem de referência para gerenciar Memoryblock

Na maioria das situações, a maneira mais eficiente de usar MemoryBlock é alocar / desalocar explicitamente. No entanto, em aplicativos complicados, usar a contagem de referência para coleta de lixo pode ser uma ideia melhor. Para ter uma contagem de referência no MemoryBlock, você pode vincular o MemoryBlock a um objeto fichário, o que ajuda a contar as referências e desalocar o MemoryBlock quando a contagem diminui para zero.

Declarando o HAL

Ao declarar o HAL, descreva uma estrutura HIDL que contém um MemoryBlock e um IBase:

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

struct MemoryBlockAllocation {
    MemoryBlock block;
    IBase refcnt;
};

Use o MemoryBlockAllocation para substituir MemoryBlock e remover o método de dar a volta a MemoryBlock . Será desatribuído por contagem de referência com o MemoryBlockAllocation . Exemplo:

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

Implementando o HAL

Exemplo de implementação do lado do serviço do 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);

Exemplo de implementação do lado do cliente do HAL:

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

Anexando / recuperando metadados

Algumas aplicações necessitam de dados adicionais para vincular com o alocados MemoryBlock . Você pode anexar / recuperar metadados usando dois métodos:

  • Se o aplicativo acessa os metadados com a mesma frequência que o próprio bloco, anexe os metadados e transmita-os todos em uma estrutura. Exemplo:

    import android.hidl.memory.block@1.0::MemoryBlock;
    
    struct MemoryBlockWithMetaData{
        MemoryBlock block;
        MetaDataStruct metaData;
    };
    
  • Se o aplicativo acessa os metadados com muito menos frequência do que o bloco, é mais eficiente transmitir os metadados passivamente com uma interface. Exemplo:

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

    Em seguida, vincule os metadados ao MemoryBlock usando o Memory Dealer. Exemplo:

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