HIDL MemoryBlock
è un livello astratto basato su hidl_memory
, HIDL
@1.0::IAllocator
e HIDL @1.0::IMapper
. È progettata per i servizi HIDL
con più blocchi di memoria per condividere un singolo heap di memoria.
Miglioramenti delle prestazioni
L'utilizzo di MemoryBlock
nelle app può ridurre notevolmente il numero di
mmap
/munmap
e errori di segmentazione dello spazio utente, con un conseguente miglioramento del rendimento.
Ad esempio:
- L'utilizzo per
hidl_memory
per ogni allocazione del buffer ha una media di 238 us/1 l'allocazione delle risorse. - L'uso di
MemoryBlock
e la condivisione di un singolohidl_memory
hanno una media di 2,82 us/1 l'allocazione delle risorse.
Architettura
L'architettura HIDL MemoryBlock
include servizi HIDL con memoria multipla
la condivisione di un singolo heap di memoria:
Figura 1. Architettura HIDL MemoryBlock
Utilizzo normale
Questa sezione fornisce un esempio di utilizzo di MemoryBlock
dichiarando prima il
HAL quindi implementa l'HAL.
Dichiara l'HAL
Per il seguente esempio IFoo HAL:
import android.hidl.memory.block@1.0::MemoryBlock;
interface IFoo {
getSome() generates(MemoryBlock block);
giveBack(MemoryBlock block);
};
Il Android.bp
è il seguente:
hidl_interface {
...
srcs: [
"IFoo.hal",
],
interfaces: [
"android.hidl.memory.block@1.0",
...
};
Implementare l'HAL
Per implementare l'HAL di esempio:
Scarica
hidl_memory
(per maggiori dettagli, fai riferimento a 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 }));
Crea un'istanza
HidlMemoryDealer
con l'oggettohidl_memory
acquisito:#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);
Alloca
MemoryBlock
, uno struct definito con HIDL.Esempio
MemoryBlock
:struct MemoryBlock { IMemoryToken token; uint64_t size; uint64_t offset; };
Esempio di utilizzo di
MemoryDealer
per allocare unMemoryBlock
:#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); ...
Dealloca
MemoryBlock
:Return<void> Foo::giveBack(const MemoryBlock& block) { memory_dealer->deallocate(block.offset); ...
Manipolare i dati:
#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()));
Configurazione
Android.bp
:shared_libs: [ "android.hidl.memory@1.0", "android.hidl.memory.block@1.0" "android.hidl.memory.token@1.0", "libhidlbase", "libhidlmemory",
Esamina il flusso per determinare se devi
lockMemory
.Normalmente,
MemoryBlock
utilizza il conteggio dei riferimenti per mantenere l'elementohidl_memory
, che èmmap()
-ed è la prima volta che una delle sueMemoryBlock 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" è stata mappata in tutto il blocco durante il ciclo di vita di attività. Esempio:#include <hidlmemory/mapping.h> sp<RefBase> lockMemory(const sp<IMemoryToken> key);
Utilizzo esteso
Questa sezione fornisce dettagli sull'utilizzo esteso di MemoryBlock
.
Utilizzare il conteggio dei riferimenti per gestire MemoryBlock
Nella maggior parte delle situazioni, il modo più efficiente per utilizzare MemoryBlock
è quello di
e allocare/deallocate. Tuttavia, nelle app complicate che utilizzano il conteggio dei riferimenti,
per la garbage collection potrebbe essere un'idea migliore. Per contare i riferimenti
MemoryBlock
, puoi associare MemoryBlock
a un oggetto binder, che aiuta a:
conta i riferimenti e dealula MemoryBlock
quando il conteggio diminuisce
a zero.
Dichiara l'HAL
Quando dichiari l'HAL, descrivi uno struct HIDL che contiene un'istruzione MemoryBlock
.
e un IBase:
import android.hidl.memory.block@1.0::MemoryBlock;
struct MemoryBlockAllocation {
MemoryBlock block;
IBase refcnt;
};
Utilizza MemoryBlockAllocation
per sostituire MemoryBlock
e rimuovere il metodo
per restituire MemoryBlock
. Viene distribuito mediante il conteggio dei riferimenti
con MemoryBlockAllocation
. Esempio:
interface IFoo {
allocateSome() generates(MemoryBlockAllocation allocation);
};
Implementare l'HAL
Esempio di implementazione lato servizio dell'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);
Esempio di implementazione lato client dell'HAL:
ifoo->allocateSome([&](const MemoryBlockAllocation& allocation){
...
);
Allega e recupera i metadati
Alcune app richiedono dati aggiuntivi per essere associate all'oggetto MemoryBlock
allocato.
Puoi aggiungere e recuperare i metadati utilizzando due metodi:
Se l'app accede ai metadati con la stessa frequenza del blocco stesso, aggiungere i metadati e trasmetterli tutti in uno struct. Esempio:
import android.hidl.memory.block@1.0::MemoryBlock; struct MemoryBlockWithMetaData{ MemoryBlock block; MetaDataStruct metaData; };
Se l'app accede ai metadati molto meno frequentemente rispetto alla blocco, è più efficiente passare i metadati in modo passivo con a riga di comando. Esempio:
import android.hidl.memory.block@1.0::MemoryBlock; struct MemoryBlockWithMetaData{ MemoryBlock block; IMetaData metaData; };
Successivamente, associa i metadati a
MemoryBlock
utilizzandoMemoryDealer
. Esempio:MemoryBlockWithMetaData memory_block; memory_block.block = dealer->allocate(size); if(HidlMemoryDealer::isOk(block)){ memory_block.metaData = new MetaData(...);