Blok pamięci HIDL

HIDL MemoryBlock to warstwa abstrakcji oparta 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 do udostępniania pojedynczego stosu pamięci.

Poprawa wydajności.

Używanie MemoryBlock w aplikacjach może znacznie zmniejszyć liczbę błędów segmentacji przestrzeni użytkownika i błędów mmap/munmap, a tym samym zwiększyć wydajność. Na przykład:

  • Użycie hidl_memory na każdą alokację bufora daje średnio 238 μs na 1 alokację.
  • Korzystanie z MemoryBlock i udostępnianie pojedynczego hidl_memory zajmuje średnio 2,82 μs na 1 przydział.

Architektura

Architektura HIDL MemoryBlock obejmuje usługi HIDL z wieloma blokami pamięci współdzielącymi jeden stos pamięci:

HIDL MemoryBlock

Rysunek 1. Architektura HIDL MemoryBlock

Normalne użytkowanie

W tej sekcji znajdziesz przykład użycia MemoryBlock. Najpierw zadeklaruj HAL, a potem go wdróż.

Zadeklaruj HAL

W przypadku tego przykładu interfejsu HAL IFoo:

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

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

Android.bp wygląda tak:

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

Wdrażanie interfejsu HAL

Aby zaimplementować przykładowy HAL:

  1. Pobierz hidl_memory (szczegółowe informacje znajdziesz w artykule 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. Utwórz instancję HidlMemoryDealer z uzyskanym 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. Przydziel MemoryBlock, czyli strukturę zdefiniowaną za pomocą HIDL.

    Przykład MemoryBlock:

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

    Przykład użycia symbolu MemoryDealer do przypisania symbolu 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. Zwolnij MemoryBlock:

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

  5. Wykonywanie operacji na danych:

    #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. Konfiguracja Android.bp:

    shared_libs: [
        "android.hidl.memory@1.0",

        "android.hidl.memory.block@1.0"

        "android.hidl.memory.token@1.0",
        "libhidlbase",
        "libhidlmemory",

  7. Sprawdź proces, aby określić, czy musisz lockMemory.

    Zwykle MemoryBlock używa licznika odwołań do utrzymywania udostępnionego hidl_memory, który jest mmap()-owany za pierwszym razem, gdy jeden z jego 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` jest mapowany w całym cyklu życia blokady. Przykład:

    #include <hidlmemory/mapping.h>

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

Rozszerzone użycie

W tej sekcji znajdziesz szczegółowe informacje o rozszerzonym użyciu MemoryBlock.

Zarządzanie obiektem MemoryBlock za pomocą licznika odwołań

W większości sytuacji najskuteczniejszym sposobem używania MemoryBlock jest jawne przydzielanie i zwalnianie pamięci. W przypadku skomplikowanych aplikacji korzystanie z liczby odwołań do odzyskiwania pamięci może być lepszym rozwiązaniem. Aby mieć liczbę odwołań do MemoryBlock, możesz powiązać MemoryBlock z obiektem wiążącym, który pomaga zliczać odwołania i zwalniać pamięć MemoryBlock, gdy liczba odwołań zmniejszy się do zera.

Zadeklaruj HAL

Podczas deklarowania HAL opisz strukturę HIDL, która zawiera MemoryBlock instancję i interfejs IBase:

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

struct MemoryBlockAllocation {
    MemoryBlock block;
    IBase refcnt;
};

Użyj MemoryBlockAllocation, aby zastąpić MemoryBlock i usunąć metodę w celu zwrotu MemoryBlock. Pamięć jest zwalniana przez zliczanie odwołań za pomocą funkcji MemoryBlockAllocation. Przykład:

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

Wdrażanie interfejsu HAL

Przykład implementacji HAL po stronie usługi:

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 HAL po stronie klienta:

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

Dołączanie i pobieranie metadanych

Niektóre aplikacje potrzebują dodatkowych danych, aby powiązać je z przydzielonym adresem MemoryBlock. Metadane możesz dołączać i pobierać na 2 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ż do bloku, 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 MemoryBlock za pomocą MemoryDealer. Przykład:

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