HIDL MemoryBlock הוא שכבה מופשטת הבנויה על hidl_memory
, HIDL @1.0::IAllocator
ו- HIDL @1.0::IMapper
. הוא מיועד לשירותי HIDL שיש להם מספר בלוקים של זיכרון לשיתוף ערימת זיכרון אחת.
שיפורי ביצועים
שימוש ב-MemoryBlock ביישומים יכול להפחית משמעותית את מספר תקלות mmap
/ munmap
ופילוח מרחב המשתמש, ובכך לשפר את הביצועים. לדוגמה:
- השימוש בכל
hidl_memory
עבור כל הקצאת מאגר ממוצע של הקצאת 238 us/1. - שימוש
MemoryBlock
ושיתוףhidl_memory
בודד ממוצע הקצאה של 2.82 us/1.
ארכיטקטורה
ארכיטקטורת HIDL MemoryBlock כוללת שירותי HIDL עם מספר בלוקי זיכרון החולקים ערימת זיכרון אחת:
איור 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 לדוגמה:
קבל את
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->allocate(2048, [&](bool success, const hidl_memory& mem) { if (!success) { /* error */ } // you can now use the hidl_memory object 'mem' or pass it }));
צור
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);
הקצה
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); ...
ביטול הקצאת
MemoryBlock
:Return<void> Foo::giveBack(const MemoryBlock& block) { memory_dealer->deallocate(block.offset); ...
מניפולציה של הנתונים:
#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()));
הגדרות
Android.bp
:shared_libs: [ "android.hidl.memory@1.0", "android.hidl.memory.block@1.0" "android.hidl.memory.token@1.0", "libhidlbase", "libhidlmemory",
סקור את הזרימה כדי לקבוע אם עליך
lockMemory
.בדרך כלל, ה-MemoryBlock משתמש בספירת הפניות כדי לשמור על
hidl_memory
המשותף שהואmmap()
-ed בפעם הראשונה שאחד מ-MemoryBlock
שלו ממופה והואmunmap()
-ed כאשר שום דבר לא מתייחס אליו. כדי לשמור על ה-hidl_memory
ממופה תמיד, אתה יכול להשתמשlockMemory
, אובייקט בסגנון RAII ששומר על ה-hidl_memory
המקביל ממופה לאורך כל מחזור חיי הנעילה. דוגמא:#include <hidlmemory/mapping.h> sp<RefBase> lockMemory(const sp<IMemoryToken> key);
שימוש מורחב
סעיף זה מספק פרטים על השימוש המורחב ב- MemoryBlock
.
שימוש בספירת הפניות לניהול חסימת זיכרון
ברוב המצבים, הדרך היעילה ביותר להשתמש ב-MemoryBlock היא הקצאה/הקצאה מפורשת. עם זאת, ביישומים מסובכים שימוש בספירת הפניות לאיסוף אשפה עשוי להיות רעיון טוב יותר. כדי לקבל ספירת הפניות ב-MemoryBlock, אתה יכול לאגד MemoryBlock עם אובייקט קלסר, שעוזר לספור את הפניות ולהקצות את ה-MemoryBlock כאשר הספירה יורדת לאפס.
מכריז על HAL
כאשר מכריזים על ה-HAL, תאר מבנה HIDL המכיל בלוק זיכרון ו-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 באמצעות סוחר הזיכרון. דוגמא:
MemoryBlockWithMetaData memory_block; memory_block.block = dealer->allocate(size); if(HidlMemoryDealer::isOk(block)){ memory_block.metaData = new MetaData(...);