HIDL MemoryBlock

O HIDL MemoryBlock é uma camada abstrata criada em 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 no desempenho

Usar MemoryBlock em apps pode reduzir significativamente o número de falhas de segmentação de mmap/munmap e espaço do usuário, melhorando assim o desempenho. Exemplo:

  • Usar por hidl_memory para cada alocação de buffer tem uma média de 238 us/1 alocação.
  • Usar MemoryBlock e compartilhar um único hidl_memory gera uma média de 2,82 us/1 alocação.

Arquitetura

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

HIDL MemoryBlock

Figura 1. Arquitetura do HIDL MemoryBlock

Uso normal

Nesta seção, fornecemos um exemplo de uso de MemoryBlock. Primeiro, declaramos a HAL e depois a implementamos.

Declarar a HAL

Para o exemplo a seguir de IFoo HAL:

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

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

O Android.bp é o seguinte:

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

Implementar a HAL

Para implementar o HAL de exemplo:

  1. Receba o hidl_memory. Para mais 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. Crie uma instância HidlMemoryDealer com o hidl_memory adquirido:

    #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 struct definida com HIDL.

    Exemplo MemoryBlock:

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

    Exemplo usando 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. Analise o fluxo para determinar se é necessário lockMemory.

    Normalmente, MemoryBlock usa a contagem de referência para manter o hidl_memory compartilhado, que é mmap()-ed na primeira vez que um dos seus 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 é mapeado durante o ciclo de vida do bloqueio. Exemplo:

    #include <hidlmemory/mapping.h>

sp<RefBase> lockMemory(const sp<IMemoryToken> key);

Uso estendido

Nesta seção, fornecemos detalhes sobre o uso estendido de MemoryBlock.

Usar a contagem de referências para gerenciar MemoryBlock

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

Declarar a HAL

Ao declarar o HAL, descreva uma struct HIDL que contenha uma instância MemoryBlock e um IBase:

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

struct MemoryBlockAllocation {
    MemoryBlock block;
    IBase refcnt;
};

Use MemoryBlockAllocation para substituir MemoryBlock e remova o método para retornar MemoryBlock. Ela é desalocada por contagem de referências com MemoryBlockAllocation. Exemplo:

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

Implementar a HAL

Exemplo da implementação do lado do serviço da 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 da implementação do HAL no lado do cliente:

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

Anexar e recuperar metadados

Alguns apps precisam de dados adicionais para serem vinculados ao MemoryBlock alocado. É possível anexar e recuperar metadados usando dois métodos:

  • Se o app acessar os metadados com a mesma frequência que o próprio bloco, adicione os metadados e transmita todos eles em uma struct. Exemplo:

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

struct MemoryBlockWithMetaData{
    MemoryBlock block;
    MetaDataStruct metaData;
};

  • Se o app acessar os metadados com muito menos frequência do que o bloco, será mais eficiente transmitir os metadados de forma passiva com uma interface. Exemplo:

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

struct MemoryBlockWithMetaData{
    MemoryBlock block;
    IMetaData metaData;
};

    Em seguida, vincule os metadados com o MemoryBlock usando MemoryDealer. Exemplo:

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