Blokada pamięci HIDL

MemoryBlock HIDL to abstrakcyjna warstwa utworzona w systemach hidl_memory, HIDL @1.0::IAllocator i HIDL @1.0::IMapper. Przeznaczone do usług HIDL które mają wiele bloków pamięci współużytkowanych na jednej stercie pamięci.

Poprawa wydajności.

Korzystanie z MemoryBlock w aplikacjach może znacznie ograniczyć liczbę mmap/munmap i błędów w podziale na segmenty według przestrzeni użytkownika, co przekłada się na poprawę skuteczności. Na przykład:

  • Wykorzystanie na hidl_memory dla każdego przydziału bufora: średnio 238 us/1 przydziału danych.
  • Korzystanie z usługi MemoryBlock i udostępnienie 1 konta hidl_memory daje średnio 2,82 us/1 przydziału danych.

Architektura

Architektura HIDL MemoryBlock obejmuje usługi HIDL z wieloma pamięcią bloki współużytkujące jeden stert pamięci:

Blokada pamięci HIDL

Rysunek 1. Architektura HIDL MemoryBlock

Normalne wykorzystanie

W tej sekcji znajdziesz przykład użycia funkcji MemoryBlock przez zadeklarowanie najpierw HAL, a następnie wdrożenie HAL.

Deklarowanie HAL

Oto przykładowy kod IFoo HAL:

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 HAL

Aby wdrożyć przykładową listę HAL:

  1. Uzyskaj hidl_memory (szczegóły znajdziesz w sekcji 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 pozyskanym 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, który jest strukturą zdefiniowaną za pomocą HIDL.

    Przykładowy element MemoryBlock:

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

    Przykład użycia parametru MemoryDealer do przydzielenia parametru 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. Przekaż MemoryBlock:

    Return<void> Foo::giveBack(const MemoryBlock& block) {
        memory_dealer->deallocate(block.offset);
    ...
    
  5. Przeprowadzaj działania 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. Zapoznaj się z instrukcjami, aby określić, czy musisz lockMemory.

    Zwykle MemoryBlock wykorzystuje liczbę plików referencyjnych, aby utrzymać współdzielone pliki hidl_memory, który jest mmap()po raz pierwszy zmapowany przez 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` w całej blokadzie` cyklu życia usługi. Przykład:

    #include <hidlmemory/mapping.h>
    
    sp<RefBase> lockMemory(const sp<IMemoryToken> key);
    

Rozszerzone użycie

Ta sekcja zawiera szczegółowe informacje na temat rozszerzonego korzystania z MemoryBlock.

Korzystanie z liczby plików referencyjnych do zarządzania MemoryBlock

W większości sytuacji najskuteczniejszym sposobem użycia funkcji MemoryBlock jest bezpośrednie przydzielać/odizolować. Jednak w skomplikowanych aplikacjach korzystających z liczby odniesień na potrzeby czyszczenia pamięci, to lepszy pomysł. włączenie zliczania plików referencyjnych, MemoryBlock, możesz powiązać MemoryBlock z obiektem separatora, co pomaga policz pliki referencyjne i awansuj z MemoryBlock, gdy liczba będzie się zmniejszać do zera.

Deklarowanie HAL

Podczas deklarowania wartości HAL opisz strukturę HIDL zawierającą MemoryBlock i IBase:

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

struct MemoryBlockAllocation {
    MemoryBlock block;
    IBase refcnt;
};

Użyj polecenia MemoryBlockAllocation, aby zastąpić metodę MemoryBlock i usunąć metodę aby oddać MemoryBlock. Została przydzielona przez liczbę referencji dzięki MemoryBlockAllocation. Przykład:

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

Wdrażanie 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 wymagają dodatkowych danych, aby powiązać z przydzielonym MemoryBlock. Metadane możesz dołączać i pobierać, korzystając z 2 metod:

  • Jeśli aplikacja uzyskuje dostęp do metadanych tak często jak do samej blokady, dołącz metadane i przekaż je wszystkie w elemencie struct. 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ż skuteczniejsze jest pasywne przekazywanie metadanych z użyciem za pomocą prostego interfejsu online. Przykład:

    import android.hidl.memory.block@1.0::MemoryBlock;
    
    struct MemoryBlockWithMetaData{
        MemoryBlock block;
        IMetaData metaData;
    };
    

    Następnie powiąż metadane z tagiem MemoryBlock za pomocą atrybutu MemoryDealer. Przykład:

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