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
O uso de MemoryBlock
em apps pode reduzir significativamente o número de
mmap
/munmap
e falhas de segmentação do espaço do usuário, melhorando a performance.
Exemplo:
- A média de uso por
hidl_memory
para cada alocação de buffer é de 238 us/1 alocação do projeto. - O uso do
MemoryBlock
e o compartilhamento de uma únicahidl_memory
resulta em média de 2,82 us/1 alocação do projeto.
Arquitetura
A arquitetura HIDL MemoryBlock
inclui serviços HIDL com várias memórias
blocos que compartilham um único heap de memória:
Figura 1. Arquitetura de HIDL MemoryBlock
Uso normal
Esta seção fornece um exemplo de uso do MemoryBlock
ao declarar primeiro a
a HAL implementando a HAL.
Declarar a HAL
Para o exemplo a seguir, IFoo HAL:
import android.hidl.memory.block@1.0::MemoryBlock;
interface IFoo {
getSome() generates(MemoryBlock block);
giveBack(MemoryBlock block);
};
O Android.bp
fica assim:
hidl_interface {
...
srcs: [
"IFoo.hal",
],
interfaces: [
"android.hidl.memory.block@1.0",
...
};
Implementar a HAL
Para implementar a HAL de exemplo:
Acesse 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 }));
Faça uma instância
HidlMemoryDealer
com ohidl_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);
Aloque
MemoryBlock
, que é uma estrutura definida com HIDL.Exemplo de
MemoryBlock
:struct MemoryBlock { IMemoryToken token; uint64_t size; uint64_t offset; };
Exemplo de uso do
MemoryDealer
para alocar umMemoryBlock
:#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); ...
Desaloque
MemoryBlock
:Return<void> Foo::giveBack(const MemoryBlock& block) { memory_dealer->deallocate(block.offset); ...
Manipular 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()));
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",
Analise o fluxo para determinar se você precisa
lockMemory
.Normalmente, o
MemoryBlock
usa a contagem de referência para manter o A propriedadehidl_memory
foi marcada commmap()
na primeira vez que um de seusMemoryBlock instances is mapped and is
munmap()-ed when nothing refers to it. To keep
hidl_memoryalways mapped, you can use
lockMemory, a RAII style object that keeps the corresponding
hidl_memory` mapeado pelo bloqueio no ciclo de vida de ML. Exemplo:#include <hidlmemory/mapping.h> sp<RefBase> lockMemory(const sp<IMemoryToken> key);
Uso estendido
Esta seção fornece detalhes sobre o uso estendido do MemoryBlock
.
Usar a contagem de referência para gerenciar o MemoryBlock
Na maioria das situações, a maneira mais eficiente de usar MemoryBlock
é explicitamente
alocar/desalocar. No entanto, em apps complicados que usam a contagem de referência
para coleta de lixo pode ser uma ideia melhor. Para ter a contagem de referência
MemoryBlock
, é possível vincular MemoryBlock
a um objeto de vinculação, o que ajuda a
conta as referências e desaloca o MemoryBlock
quando a contagem diminui.
a zero.
Declarar a HAL
Ao declarar a HAL, descreva um struct HIDL que contenha um MemoryBlock
e um IBase:
import android.hidl.memory.block@1.0::MemoryBlock;
struct MemoryBlockAllocation {
MemoryBlock block;
IBase refcnt;
};
Use MemoryBlockAllocation
para substituir MemoryBlock
e remover o método
para retribuir MemoryBlock
. Ele é desalocado por contagem de referência
com MemoryBlockAllocation
. Exemplo:
interface IFoo {
allocateSome() generates(MemoryBlockAllocation allocation);
};
Implementar a HAL
Exemplo da implementação da HAL no lado do serviço:
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 da HAL no lado do cliente:
ifoo->allocateSome([&](const MemoryBlockAllocation& allocation){
...
);
Anexar e recuperar metadados
Alguns apps precisam de mais dados para serem vinculados ao MemoryBlock
alocado.
É possível anexar e recuperar metadados usando dois métodos:
Se o app acessa os metadados com a mesma frequência que o próprio bloco, anexar os metadados e transmiti-los em um struct. Exemplo:
import android.hidl.memory.block@1.0::MemoryBlock; struct MemoryBlockWithMetaData{ MemoryBlock block; MetaDataStruct metaData; };
Se o aplicativo acessar os metadados com muito menos frequência do que o é mais eficiente passar os metadados passivamente com uma interface gráfica do usuário. Exemplo:
import android.hidl.memory.block@1.0::MemoryBlock; struct MemoryBlockWithMetaData{ MemoryBlock block; IMetaData metaData; };
Em seguida, vincule os metadados à
MemoryBlock
usandoMemoryDealer
. Exemplo:MemoryBlockWithMetaData memory_block; memory_block.block = dealer->allocate(size); if(HidlMemoryDealer::isOk(block)){ memory_block.metaData = new MetaData(...);