HIDL MemoryBlock
היא שכבה מופשטת שמבוססת על hidl_memory
, HIDL
@1.0::IAllocator
ו-HIDL @1.0::IMapper
. הוא מיועד לשירותי HIDL שיש להם כמה בלוקים של זיכרון כדי לשתף ערימה אחת של זיכרון.
שיפורי ביצועים
שימוש ב-MemoryBlock
באפליקציות יכול להפחית באופן משמעותי את מספר השגיאות של mmap
/munmap
ושל חלוקת המרחב של המשתמש, וכך לשפר את הביצועים.
לדוגמה:
- השימוש ב-
hidl_memory
לכל הקצאה של מאגר נתונים ממוצע 238 אלפיות שנייה להקצאה. - כשמשתמשים ב-
MemoryBlock
ושיתוף שלhidl_memory
בודד, מקבלים בממוצע 2.82 דולר ארה"ב להקצאה.
ארכיטקטורה
הארכיטקטורה של HIDL MemoryBlock
כוללת שירותי HIDL עם כמה בלוקים של זיכרון שמשתמשים בערימה אחת של זיכרון:
איור 1. ארכיטקטורת HIDL MemoryBlock
שימוש רגיל
בקטע הזה נספק דוגמה לשימוש ב-MemoryBlock
, תחילה בהצהרה על ה-HAL ולאחר מכן בהטמעת ה-HAL.
הצהרת ה-HAL
בדוגמה הבאה של HAL של IFoo:
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
, שהוא מבנה (struct) שמוגדר באמצעות 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()
בפעם הראשונה שאחד מה-MemoryBlock instances is mapped and is
munmap()-ed when nothing refers to it. To keep
hidl_memoryalways 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
לאובייקט קישור, וכך לספור את ההפניות ולהקצות להן את 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(...);