HIDL MemoryBlock to abstrakcyjna warstwa zbudowana na hidl_memory
, HIDL @1.0::IAllocator
i HIDL @1.0::IMapper
. Jest przeznaczony dla usług HIDL, które mają wiele bloków pamięci współdzielących pojedynczy stos pamięci.
Ulepszenia w wydajności
Używanie MemoryBlock w aplikacjach może znacznie zmniejszyć liczbę błędów mmap
/ munmap
i segmentacji przestrzeni użytkownika, poprawiając w ten sposób wydajność. Na przykład:
- Użycie per
hidl_memory
dla każdego alokacji bufora wynosi średnio 238 us/1 alokacji. - Korzystanie z
MemoryBlock
i współdzielenie pojedynczejhidl_memory
wynosi średnio 2,82 us/1.
Architektura
Architektura HIDL MemoryBlock obejmuje usługi HIDL z wieloma blokami pamięci współdzielącymi pojedynczy stos pamięci:
Rysunek 1. Architektura HIDL MemoryBlock
Normalne użytkowanie
W tej sekcji przedstawiono przykład użycia modułu MemoryBlock poprzez najpierw zadeklarowanie warstwy HAL, a następnie jej implementację.
Deklarowanie HAL
Dla następującego przykładu IFoo HAL:
import android.hidl.memory.block@1.0::MemoryBlock;
interface IFoo {
getSome() generates(MemoryBlock block);
giveBack(MemoryBlock block);
};
Plik Android.bp
wygląda następująco:
hidl_interface {
...
srcs: [
"IFoo.hal",
],
interfaces: [
"android.hidl.memory.block@1.0",
...
};
Implementacja HAL-a
Aby zaimplementować przykładowy HAL:
Pobierz
hidl_memory
(więcej szczegółów znajdziesz w 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 }));
Utwórz
HidlMemoryDealer
z nabytą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);
Przydziel
MemoryBlock
, która jest strukturą zdefiniowaną za pomocą HIDL.Przykładowy
MemoryBlock
:struct MemoryBlock { IMemoryToken token; uint64_t size; uint64_t offset; };
Przykład użycia
MemoryDealer
do przydzieleniaMemoryBlock
:#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); ...
Usuń alokację
MemoryBlock
:Return<void> Foo::giveBack(const MemoryBlock& block) { memory_dealer->deallocate(block.offset); ...
Manipuluj danymi:
#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()));
Skonfiguruj
Android.bp
:shared_libs: [ "android.hidl.memory@1.0", "android.hidl.memory.block@1.0" "android.hidl.memory.token@1.0", "libhidlbase", "libhidlmemory",
Przejrzyj przepływ, aby określić, czy musisz
lockMemory
.Zwykle moduł MemoryBlock używa licznika odwołań do obsługi współdzielonej
hidl_memory
, która jest poddawanammap()
-ed przy pierwszym mapowaniu jednego z jego blokówMemoryBlock
i jest poddawanamunmap()
-ed, gdy nic się do niego nie odnosi. Abyhidl_memory
było zawsze mapowane, możesz użyćlockMemory
, obiektu w stylu RAII, który utrzymuje odpowiednie mapowaniehidl_memory
przez cały cykl życia blokady. Przykład:#include <hidlmemory/mapping.h> sp<RefBase> lockMemory(const sp<IMemoryToken> key);
Rozszerzone użytkowanie
Ta sekcja zawiera szczegółowe informacje na temat rozszerzonego użycia MemoryBlock
.
Używanie liczby referencji do zarządzania blokiem pamięci
W większości sytuacji najskuteczniejszym sposobem użycia MemoryBlock jest jawne przydzielenie/cofnięcie przydziału. Jednak w skomplikowanych aplikacjach lepszym pomysłem może być użycie liczby odwołań do usuwania elementów bezużytecznych. Aby mieć liczbę odwołań w MemoryBlock, możesz powiązać MemoryBlock z obiektem spoiwa, co pomaga policzyć odniesienia i zwolnić MemoryBlock, gdy liczba spadnie do zera.
Deklarowanie HAL
Deklarując warstwę HAL, opisz strukturę HIDL zawierającą blok pamięci i bazę IBase:
import android.hidl.memory.block@1.0::MemoryBlock;
struct MemoryBlockAllocation {
MemoryBlock block;
IBase refcnt;
};
Użyj MemoryBlockAllocation
, aby zastąpić MemoryBlock
i usuń metodę, aby zwrócić MemoryBlock
. Zostanie on zwolniony przez zliczenie referencji za pomocą MemoryBlockAllocation
. Przykład:
interface IFoo {
allocateSome() generates(MemoryBlockAllocation allocation);
};
Implementacja HAL-a
Przykład implementacji HAL po stronie usługowej:
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);
Przykład implementacji warstwy HAL po stronie klienta:
ifoo->allocateSome([&](const MemoryBlockAllocation& allocation){
...
);
Załączanie/odzyskiwanie metadanych
Niektóre aplikacje potrzebują dodatkowych danych do powiązania z przydzielonym MemoryBlock
. Możesz dołączyć/odzyskać metadane na dwa sposoby:
Jeśli aplikacja uzyskuje dostęp do metadanych tak często, jak sam blok, dołącz metadane i przekaż je wszystkie w strukturze. Przykład:
import android.hidl.memory.block@1.0::MemoryBlock; struct MemoryBlockWithMetaData{ MemoryBlock block; MetaDataStruct metaData; };
Jeśli aplikacja uzyskuje dostęp do metadanych znacznie rzadziej niż blok, bardziej efektywne jest pasywne przekazywanie metadanych za pomocą interfejsu. Przykład:
import android.hidl.memory.block@1.0::MemoryBlock; struct MemoryBlockWithMetaData{ MemoryBlock block; IMetaData metaData; };
Następnie powiąż metadane z modułem MemoryBlock za pomocą modułu Memory Dealer. Przykład:
MemoryBlockWithMetaData memory_block; memory_block.block = dealer->allocate(size); if(HidlMemoryDealer::isOk(block)){ memory_block.metaData = new MetaData(...);