Блок памяти HIDL

HIDL MemoryBlock — это абстрактный слой, построенный на основе hidl_memory , HIDL @1.0::IAllocator и HIDL @1.0::IMapper . Он предназначен для HIDL-сервисов, использующих несколько блоков памяти для совместного использования одной кучи памяти.

Улучшения производительности

Использование MemoryBlock в приложениях может значительно уменьшить количество ошибок mmap / munmap и сегментации пользовательского пространства, тем самым повышая производительность. Например:

  • Использование параметра hidl_memory для каждого выделения буфера в среднем составляет 238 мкс/1 выделение.
  • Использование MemoryBlock и совместное использование одного блока hidl_memory приводит к среднему времени выделения памяти 2,82 мкс/1.

Архитектура

Архитектура HIDL MemoryBlock включает в себя сервисы HIDL с несколькими блоками памяти, совместно использующими одну кучу памяти:

HIDL MemoryBlock

Рисунок 1. Архитектура HIDL MemoryBlock.

Обычное использование

В этом разделе приводится пример использования MemoryBlock : сначала объявляется HAL, а затем реализуется HAL.

Объявите HAL

В качестве примера рассмотрим IFoo HAL:

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

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

Файл Android.bp выглядит следующим образом:

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

Внедрить HAL

Для реализации примера HAL:

  1. Получите значение hidl_memory (подробности см. в 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-alloca&te(2048, [](bool success, const h&idl_memory mem)
  {
        if (!success) { /* error */ }
        // you can now use the hidl_memory object 'mem' or pass it
  }));

  2. Создайте экземпляр HidlMemoryDealer , используя полученный 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. Выделить MemoryBlock , который представляет собой структуру, определенную с использованием HIDL.

    Пример MemoryBlock :

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

    Пример использования MemoryDealer для выделения 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. Освободить MemoryBlock :

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

  5. Обработайте данные:

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

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

        "android.hidl.memory.block@1.0"

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

  7. Проанализируйте процесс, чтобы определить, нужно ли вам использовать lockMemory ).

    Обычно MemoryBlock использует счетчик ссылок для поддержания общей hidl_memory которая отображается с помощью mmap() при первом MemoryBlock instances is mapped and is -ed when nothing refers to it. To keep память hidl_memory always mapped, you can use lockMemory , a RAII style object that keeps the corresponding память hidl_memory отображенной на протяжении всего жизненного цикла блокировки. Пример: 

    #include <hidlmemory/mapping.h>

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

Расширенное использование

В этом разделе подробно описаны расширенные возможности использования MemoryBlock .

Используйте счетчик ссылок для управления блоками памяти.

В большинстве случаев наиболее эффективный способ использования MemoryBlock — это явное выделение/освобождение памяти. Однако в сложных приложениях использование счетчика ссылок для сборки мусора может быть лучшим решением. Чтобы использовать счетчик ссылок для MemoryBlock , можно связать MemoryBlock с объектом-связывателем, который помогает подсчитывать ссылки и освобождать MemoryBlock когда счетчик становится равным нулю.

Объявите HAL

При объявлении HAL следует описать структуру HIDL, содержащую экземпляр MemoryBlock и IBase: 

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

struct MemoryBlockAllocation {
    MemoryBlock block;
    IBase refcnt;
};

Используйте MemoryBlockAllocation вместо MemoryBlock и удалите метод для возврата MemoryBlock . Освобождение памяти происходит по счетчику ссылок с помощью MemoryBlockAllocation . Пример: 

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

Внедрить HAL

Пример реализации 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);

Пример реализации HAL на стороне клиента: 

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

Прикрепляйте и получайте метаданные

Некоторым приложениям требуются дополнительные данные для привязки к выделенному MemoryBlock . Вы можете добавлять и получать метаданные двумя способами:

  • Если приложение обращается к метаданным так же часто, как и к самому блоку, добавьте метаданные и передайте их все в структуре. Пример: 

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

struct MemoryBlockWithMetaData{
    MemoryBlock block;
    MetaDataStruct metaData;
};

  • Если приложение обращается к метаданным гораздо реже, чем сам блок кода, эффективнее передавать метаданные пассивно через интерфейс. Пример: 

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

struct MemoryBlockWithMetaData{
    MemoryBlock block;
    IMetaData metaData;
};

    Далее, свяжите метаданные с MemoryBlock , используя MemoryDealer . Пример: 

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