งบประมาณหน่วยความจำของแอปช่วยให้แอปกำหนดขีดจำกัดแบบยืดหยุ่นสำหรับปริมาณหน่วยความจำที่แอปเก็บไว้ในหน่วยความจำได้ เมื่อแอปใช้งบประมาณเกิน ระบบจะไม่สิ้นสุดการทำงานของแอป แต่จะเรียกคืนหน่วยความจำที่แอปไม่ได้ใช้เมื่อเร็วๆ นี้แทน เพื่อให้แอปเก็บชุดการทำงานไว้ (หน่วยความจำที่แอปต้องการอย่างมากสำหรับสิ่งที่ผู้ใช้กำลังทำ) และส่งคืนส่วนที่เหลือให้อุปกรณ์
งบประมาณจะมีประโยชน์มากที่สุดเมื่อคุณทราบชุดการทำงานของแอปและต้องการตรวจสอบการใช้ทรัพยากร เช่น สำหรับแอประบบและแอปที่รวมมาด้วย หรือสำหรับแอปที่กำหนดเป้าหมายเป็นอุปกรณ์ที่มีข้อจำกัดด้านหน่วยความจำ
หน้านี้ครอบคลุมหัวข้อต่อไปนี้
- วิธีการทำงานของงบประมาณหน่วยความจำ: ดูสิ่งที่จะเกิดขึ้นเมื่อแอปใช้งบประมาณเกิน
- ประกาศงบประมาณในไฟล์ Manifest ของ Android: กำหนดงบประมาณสถานะคงที่สำหรับสถานะกระบวนการแต่ละสถานะ ซึ่งเป็นแนวทางที่แนะนำ
- API รันไทม์: ตรวจสอบการใช้งาน จำกัดงบประมาณให้เข้มงวดขึ้นขณะรันไทม์ และคอยฟังแรงกดดันด้านหน่วยความจำจาก Kotlin หรือ Java
- ปรับเทียบ ทดสอบ และเผยแพร่งบประมาณ: ค้นหางบประมาณที่เหมาะสมสำหรับแอป ทดสอบ และเผยแพร่เป็นระยะๆ
วิธีการทำงานของงบประมาณหน่วยความจำ
ระบบจะรักษาสมดุลของงบประมาณโดยใช้การขับไล่และการสลับหน่วยความจำเพื่อนำหน้าหน่วยความจำที่ไม่ได้ใช้เมื่อเร็วๆ นี้ออก โดยมุ่งเน้นที่หน่วยความจำที่ใช้ของแอปในชุดการทำงานปัจจุบัน เมื่อแอปใช้หน่วยความจำเกินงบประมาณที่ประกาศไว้ ระบบปฏิบัติการจะกำหนดเป้าหมายการเรียกคืนหน่วยความจำไปที่แอปนั้นโดยเฉพาะ ดังนี้
- ระบบจะลบหน้าเว็บที่สะอาดซึ่งมีไฟล์สำรอง (เช่น โค้ดที่ไม่ได้ใช้งานและเนื้อหาที่แมป) ออกก่อน เนื่องจากสามารถอ่านซ้ำจากพื้นที่เก็บข้อมูลได้หากจำเป็น
- ระบบจะเขียนหน้าที่มีไฟล์สำรองซึ่งมีการแก้ไขกลับไปยังพื้นที่เก็บข้อมูลและนำออก
- หน้าหน่วยความจำที่ไม่ระบุตัวตน (เช่น การจัดสรรฮีป) จะถูกบีบอัดและสลับเป็น zRAM
การเรียกคืนจะทำให้มีพื้นที่สำหรับการจัดสรรใหม่และทำให้การใช้หน่วยความจำของแอปอยู่ภายในงบประมาณ
ตราบใดที่มีพื้นที่ว่างระหว่างสิ่งที่แอปต้องการ ณ เวลาใดเวลาหนึ่ง (ชุดการทำงาน) กับงบประมาณที่ตั้งไว้ แอปจะยังคงทำงานตามปกติ หากแอปกำหนดงบประมาณที่น้อยกว่าชุดการทำงาน ประสิทธิภาพของแอปที่รันไทม์อาจช้าลงได้
หากต้องการดูวิธีที่ระบบปฏิบัติการติดตามและเรียกคืนหน่วยความจำ โปรดดูคู่มือสถาปัตยกรรมหน่วยความจำ
- การเรียกคืนหน่วยความจำและการสลับ: อธิบายวิธีที่ระบบปฏิบัติการเรียกเก็บเงินจากฮีปแบบไม่ระบุตัวตนส่วนตัวและหน้าเว็บที่ใช้ไฟล์เป็นฐานไปยังแอปของคุณ และเรียกคืนหน้าเว็บที่ไม่มีการใช้งานเมื่อเกินงบประมาณ
- แนวคิดพื้นฐาน: อธิบายสาเหตุที่ระบบยกเว้นหน่วยความจำ Zygote ที่ใช้ร่วมกันออกจากงบประมาณของแอป และความสัมพันธ์ระหว่างงบประมาณที่ใช้กับ RSS แบบไม่ระบุตัวตน + สลับในการตรวจวัดระยะไกลภาคสนาม
- บิตแมปและหน่วยความจำ: อธิบายวิธีพิจารณาบิตแมปฮาร์ดแวร์ที่สนับสนุนโดย GPU และการจัดสรร DMA-BUF นอกฮีปและงบประมาณหน่วยความจำของแอป
ประกาศงบประมาณในไฟล์ Manifest ของ Android
ใช้ AndroidManifest.xml เพื่อประกาศงบประมาณหน่วยความจำในสภาวะคงที่ ซึ่งเป็นงบประมาณพื้นฐานที่แอปของคุณทำงานในระหว่างการใช้งานปกติ
การประกาศไฟล์ Manifest ไม่จำเป็นต้องใช้โค้ดรันไทม์ โดยจะมีผลเมื่อเริ่มต้นกระบวนการ และสลับงบประมาณในสถานะforeground, perceptible และbackground PackageManager.getMemoryBudgets แสดงการประกาศงบประมาณ <application> แบบคงที่ หากต้องการทดสอบงบประมาณและเผยแพร่ด้วยการย้อนกลับจากระยะไกลก่อนที่จะคอมมิตลงในไฟล์ Manifest โปรดดูหัวข้อปรับเทียบ ทดสอบ และเผยแพร่งบประมาณ
การประกาศ <memory-budget> จะมีผลในอุปกรณ์ที่ใช้ Android 17 QPR2 (ระดับ API 37.2) ขึ้นไป ใน Android เวอร์ชันที่ต่ำกว่า โปรแกรมแยกวิเคราะห์ไฟล์ Manifest ของแพลตฟอร์มจะละเว้นองค์ประกอบ XML ที่ไม่รู้จัก คุณจึงใช้ <memory-budget> ได้โดยไม่ส่งผลกระทบต่อความเข้ากันได้แบบย้อนหลัง
กำหนดค่าบิวด์
คุณไม่จำเป็นต้องเพิ่ม minSdk หรือ targetSdk เพื่อใช้บัดเจ็ตหน่วยความจำของแอป
การประกาศงบประมาณต่อกระบวนการภายใน <processes> ต้องใช้ปลั๊กอิน Android Gradle เวอร์ชัน 9.5.0 ขึ้นไป หากต้องการคอมไพล์แอตทริบิวต์ไฟล์ Manifest <memory-budget>, MemoryBudgetManager และ Build.VERSION_CODES_FULL.CINNAMON_BUN_2 ให้ตั้งค่า compileSdk เป็นระดับ API 37 โดยใช้ minorApiLevel = 2 ในไฟล์ build.gradle.kts หรือ build.gradle ของโมดูล ดังนี้
Kotlin
android {
compileSdk {
version = release(37) {
minorApiLevel = 2
}
}
}
ดึงดูด
android {
compileSdk {
version = release(37) {
it.minorApiLevel = 2
}
}
}
ประกาศงบประมาณพื้นฐาน
สำหรับแอปส่วนใหญ่ การกำหนดงบประมาณเดียวสำหรับแอปพลิเคชันเป็นสิ่งเดียวที่จำเป็น ประกาศองค์ประกอบ <memory-budget> ไว้ภายในแท็ก <application> โดยตรง ดังนี้
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.simpleapp">
<application
android:label="@string/app_name">
<!-- Baseline budget for the application -->
<memory-budget android:maxMb="256" />
</application>
</manifest>
ซึ่งจะกำหนดงบประมาณหน่วยความจำที่ใช้ประจำ 256 MB สำหรับกระบวนการและสถานะทั้งหมดของแพ็กเกจ เมื่อหน่วยความจำที่แอปใช้เกิน 256 MB ระบบปฏิบัติการจะตัดหน้าหน่วยความจำที่ไม่มีการใช้งานออกโดยใช้การขับออกและการสลับ
ปรับงบประมาณตามสถานะของกระบวนการ
แอปต้องใช้หน่วยความจำในปริมาณที่แตกต่างกัน โดยขึ้นอยู่กับระดับการมองเห็นของผู้ใช้ ดังนี้
- เบื้องหน้า: กระบวนการกำลังโฮสต์กิจกรรมที่มองเห็นได้ซึ่งโต้ตอบกับผู้ใช้ โดยทั่วไปแล้ว สถานะนี้จะมีขนาดใหญ่ที่สุดเนื่องจาก UI และกราฟิกที่ใช้งานอยู่
- รับรู้ได้: ผู้ใช้รับรู้ถึงกระบวนการได้ แต่ไม่ได้โฮสต์หน้าต่างที่มองเห็นได้ (เช่น โฮสต์บริการที่ทำงานอยู่เบื้องหน้าสำหรับการเล่นสื่อ, การดาวน์โหลดที่ทำงานอยู่เบื้องหลัง, การนำทางแบบเลี้ยวต่อเลี้ยว หรือวิธีการป้อนข้อมูลที่ทำงานอยู่)
- เบื้องหลัง: กระบวนการกำลังเรียกใช้งานเบื้องหลัง ตัวรับ หรือการซิงค์ข้อมูล โดยคาดว่าจะใช้พื้นที่น้อยที่สุด
คุณสามารถประกาศส่วนคำสั่ง <memory-budget> หลายรายการเพื่อจับคู่สถานะต่อไปนี้ได้
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.simpleapp">
<application
android:label="@string/app_name">
<!-- Default budget for visible foreground UI -->
<memory-budget android:maxMb="200" />
<!-- Tighter budget when playing audio in background -->
<memory-budget
android:maxMb="120"
android:state="perceptible" />
<!-- Minimal budget when fully in background -->
<memory-budget
android:maxMb="48"
android:state="background" />
</application>
</manifest>
ไม่จำเป็นต้องมีส่วนหน้าหรือส่วนที่ละไว้ หากคุณประกาศเฉพาะส่วนคำสั่ง perceptible หรือ background สถานะที่มีความสำคัญสูงกว่า เช่น foreground จะยังคงไม่ถูกจำกัดโดยงบประมาณของแอป การละเว้น android:state
จะใช้ค่าเริ่มต้นเป็น foreground ซึ่งจะส่งต่อเป็น perceptible และ background
เว้นแต่จะมีส่วนคำสั่งที่ตามมาซึ่งลบล้างสถานะเหล่านั้น โปรดดูรายละเอียดเกี่ยวกับการจัดลำดับส่วนคำสั่งที่หัวข้อกฎการแก้ไข: ส่วนคำสั่งที่เกี่ยวข้องล่าสุดจะมีผล
เมื่อกำหนดขนาดงบประมาณสำหรับแต่ละสถานะ ให้กำหนดเป้าหมายชุดการทำงานที่ใช้งานอยู่ของสถานะนั้นๆ แทนที่จะเป็นหน่วยความจำที่ใช้สูงสุด (RSS High-Water Mark)
- ปรับขนาดงบประมาณ
foregroundเพื่อการแสดงผลเฟรมที่ราบรื่น: ให้ UI เบื้องหน้ามีพื้นที่ว่างเพียงพอสำหรับชุดการทำงานที่ใช้งานอยู่ เพื่อไม่ให้การเรียกคืนแบบซิงโครนัสทำให้การแสดงผลเฟรมล่าช้า หากแอปของคุณมีเวิร์กโฟลว์แบบสแตนด์อโลนที่ใช้หน่วยความจำมาก (เช่น โปรแกรมแก้ไขรูปภาพหรือวิดีโอความละเอียดสูง) ให้พิจารณาย้ายกิจกรรมนั้นไปยังกระบวนการเฉพาะ (ดูแอปแบบหลายกระบวนการ) เพื่อให้มีการจัดสรรงบประมาณอย่างอิสระและถูกทำลายเมื่อผู้ใช้ออกจากแอป - กำหนดงบประมาณ
backgroundอย่างเข้มงวดสำหรับงานแบบ Headless: RSS พื้นหลังสูงในการตรวจวัดระยะไกลภาคสนามมักสะท้อนถึงการจัดสรร UI ที่คงไว้หลังจากออกจากเบื้องหน้า (ดูการจัดวางบริการที่มีผลผูกพันร่วมกับ UI ที่ใช้หน่วยความจำมากและการปล่อยหน่วยความจำเพื่อตอบสนองต่อเหตุการณ์) หรือการอ่านไฟล์แบบครั้งเดียวระหว่างการจัดทำดัชนีและการซิงค์ในเบื้องหลัง เนื่องจากการทำงานเบื้องหลังแบบไม่มีส่วนหัวไม่มีกำหนดเวลาเฟรม การขับไล่หน้าแคชไฟล์แบบครั้งเดียวและการสลับหน้าฮีปที่ไม่ได้ใช้งานไปยัง zRAM เมื่อการซิงค์เบื้องหลังจัดสรรเกินงบประมาณชั่วคราวจะไม่ทำให้เกิดความล่าช้าที่ผู้ใช้มองเห็นได้ ขณะเดียวกันก็ป้องกันไม่ให้การเพิ่มขึ้นอย่างรวดเร็วในเบื้องหลังขับไล่แอปที่ทำงานอยู่เบื้องหน้าของผู้ใช้
ดูเวิร์กโฟลว์แบบทีละขั้นตอนได้ที่หัวข้อปรับเทียบงบประมาณ
วิธีจับคู่สถานะงบประมาณกับสถานะกระบวนการ
แพลตฟอร์มจะแมปสถานะงบประมาณที่ประกาศไว้กับสถานะกระบวนการรันไทม์ตาม RunningAppProcessInfo.importance ซึ่ง Activity Manager จะคำนวณจากทั้งคอมโพเนนต์ที่ใช้งานอยู่ของกระบวนการเองและการผูกบริการหรือการค้นหา Content Provider ที่เข้ามาจากแอปอื่นๆ ดังนี้
foreground: การโต้ตอบของผู้ใช้ที่ทำงานอยู่และมองเห็นได้ เช่น การโฮสต์กิจกรรมที่กลับมาทำงานอีกครั้ง การรักษาสถานะแอปที่อยู่ด้านบนสุดเมื่อหน้าจอปิดลง หรือการโฮสต์บริการหรือ Content Provider ที่แอปที่ทำงานอยู่เบื้องหน้าด้านบนสุดเชื่อมโยงหรือค้นหาอยู่perceptible: ภาระงานที่ผู้ใช้รับรู้ได้โดยไม่มีหน้าต่างที่มองเห็นได้ เช่น การเล่นสื่อที่ใช้งานอยู่ การนำทางแบบเลี้ยวต่อเลี้ยว การจับภาพจากกล้องหรือไมโครโฟน การดาวน์โหลดที่ทำงานอยู่เบื้องหลัง บริการที่ทำงานอยู่เบื้องหน้าสำหรับการซิงค์ข้อมูล หรือบริการที่เชื่อมโยงกับไคลเอ็นต์ที่ทำงานอยู่เบื้องหน้าโดยใช้แฟล็ก เช่นBIND_NOT_FOREGROUND(ดูการควบคุมการรับค่าด้วยแฟล็ก BIND) แม้ว่าเมตริกแพลตฟอร์มภายในอาจติดป้ายกำกับภาระงานเหล่านี้บางส่วนเป็นPROCESS_STATE_IMPORTANT_FOREGROUNDแต่ค่าคงที่ภายในนั้นไม่ได้หมายถึงกรอบเวลาที่มองเห็นได้ และอยู่ภายใต้งบประมาณperceptiblebackground: งานที่ผู้ใช้ไม่สามารถรับรู้ได้ทันที เช่น งานที่ทำงานอยู่เบื้องหลัง การปลุก และ Broadcast Receiver
ตารางต่อไปนี้แสดงวิธีแมประดับความสำคัญของรันไทม์กับสถานะไฟล์ Manifest
ไฟล์ Manifest android:state |
ความสำคัญของรันไทม์ (RunningAppProcessInfo) |
องค์ประกอบทั่วไป |
|---|---|---|
foreground |
IMPORTANCE_FOREGROUNDIMPORTANCE_TOP_SLEEPING |
กิจกรรมที่มองเห็นได้ซึ่งกลับมาทำงานอีกครั้ง, แอปยอดนิยมที่มีหน้าจอล็อกอยู่, บริการหรือ Content Provider ที่เชื่อมโยงกับแอปยอดนิยม |
perceptible |
IMPORTANCE_FOREGROUND_SERVICEIMPORTANCE_VISIBLE |
การเล่นสื่อ การนำทาง การดาวน์โหลด หรือบริการที่ทำงานอยู่เบื้องหน้าเพื่อซิงค์ข้อมูลที่ทำงานอยู่ บริการที่เชื่อมโยงกับบริการที่ทำงานอยู่เบื้องหน้าหรือแฟล็กที่มองเห็นได้ |
background |
IMPORTANCE_PERCEPTIBLEIMPORTANCE_CANT_SAVE_STATEIMPORTANCE_SERVICEIMPORTANCE_CACHED |
งานที่ทำอยู่เบื้องหลัง, ตัวรับ, การซิงค์ในเบื้องหลัง และกระบวนการที่แคชไว้ |
ดูรายละเอียดเกี่ยวกับวิธีที่การผูกไคลเอ็นต์ยกระดับกระบวนการโฮสต์บริการหรือผู้ให้บริการ และวิธีที่กระบวนการเปลี่ยนกลับไปเป็น background หรือ cached หลังจากที่ไคลเอ็นต์ยกเลิกการเชื่อมโยงหรือย้ายออกจากหน้าจอได้ที่การผูกบริการและสถานะกระบวนการ
เมื่อกระบวนการเข้าสู่สถานะแคช (IMPORTANCE_CACHED) โดยไม่มีคอมโพเนนต์ที่ทำงานอยู่ แพลตฟอร์มจะยังคงบังคับใช้งบประมาณหน่วยความจำ background ควบคู่ไปกับการหยุดทำงานชั่วคราวและการเรียกคืนกระบวนการที่แคชไว้ เพื่อจำกัดกระบวนการแม้ว่าจะไม่มีการหยุดทำงานชั่วคราวหรือการบีบอัดก็ตาม
ตรวจสอบสถานะกระบวนการและงบประมาณของแอป
วิธีหนึ่งในการตรวจสอบสถานะกระบวนการที่ทำงานอยู่ของแอปและความสำคัญในระหว่างการพัฒนาคือการค้นหา Activity Manager โดยใช้ ADB ดังนี้
adb shell dumpsys activity processes <package-name>
ตัวอย่างแบบย่อต่อไปนี้แสดงรายการบันทึกกระบวนการและรายการควบคุม OOM สำหรับแอปที่เรียกใช้บริการที่ทำงานอยู่เบื้องหน้า
ACTIVITY MANAGER RUNNING PROCESSES (dumpsys activity processes)
All known processes:
*APP* UID 10123 ProcessRecord{edf056c 3919:com.example.app/u0a123}
pid=3919
oom adj: max=1001 curRaw=200 setRaw=200 cur=200 set=200
curProcState=4 mRepProcState=4 setProcState=4 lastStateTime=-42s360ms
hasStartedServices=true
mHasForegroundServices=true forcingToImportant=null
...
Process OOM control (48 total):
Proc #22: prcp F/S/FGS ---NFU-TI t: 0 3919:com.example.app/u0a123 (fg-service)
oom: max=1001 curRaw=200 setRaw=200 cur=200 set=200
state: cur=FGS set=FGS lastRss=0.00 lastCachedRss=0.00
ในเอาต์พุตนี้
curProcState=4และstate: cur=FGSแสดงให้เห็นว่ากระบวนการอยู่ในสถานะบริการที่ทำงานอยู่เบื้องหน้า หากแอปโฮสต์กิจกรรมที่มองเห็นได้และทำงานอยู่ ระบบจะแสดงเป็นTOPหากแอปกำลังเรียกใช้คอมโพเนนต์ที่ทำงานอยู่เบื้องหน้าที่สำคัญ (เช่น การดาวน์โหลดหรือการซิงค์) สถานะจะปรากฏเป็นIMPF- ในตารางควบคุม OOM ของกระบวนการ
prcpบ่งชี้ว่ากระบวนการได้รับการประเมินภายใต้ระดับความสำคัญที่รับรู้ได้ ซึ่งสอดคล้องกับงบประมาณperceptible
วิธีตรวจสอบการใช้งานหน่วยความจำที่ใช้ประจำในปัจจุบันของแอป
adb shell dumpsys meminfo <package-name>
แอปแบบหลายกระบวนการ
หากแอปพลิเคชันแบ่งงานออกเป็นหลายกระบวนการ ให้กำหนดค่างบประมาณกระบวนการเฉพาะโดยใช้แท็ก <process> ภายใน <processes>
ตัวอย่างเช่น ลองพิจารณาแอปสตรีมมิงเพลง (com.example.radio) ดังนี้
- กระบวนการหลัก: โฮสต์ UI ที่มองเห็นได้และเครื่องมือเล่นเสียง (
MediaSessionServiceที่มีบริการที่ทำงานอยู่เบื้องหน้าmediaPlayback) เมื่อมองเห็นได้ กระบวนการจะทำงานภายใต้งบประมาณเบื้องหน้า 180 MB เมื่อผู้ใช้ออกจากแอปขณะที่เพลงยังเล่นอยู่ กระบวนการจะเข้าสู่สถานะperceptibleซึ่งงบประมาณ 64 MB เพียงพอสำหรับเครื่องมือการเล่นและบัฟเฟอร์เสียง - กระบวนการซิงค์ (
:sync): กระบวนการเฉพาะที่เรียกใช้การซิงค์ข้อมูลเมตาในเบื้องหลังและการจัดทำดัชนีการดาวน์โหลด เนื่องจากกระบวนการนี้จะทำงานในเบื้องหลังเท่านั้น คุณจึงไม่จำเป็นต้องประกาศstate="background"อย่างชัดเจน โดยจะใช้งบประมาณเดียว
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.radio">
<application
android:label="@string/app_name">
<!-- Package baseline: main process with UI and audio playback -->
<memory-budget android:maxMb="180" />
<!-- Tighter budget when audio plays in the background -->
<memory-budget
android:maxMb="64"
android:state="perceptible" />
<processes>
<!-- Dedicated background sync process -->
<process android:process=":sync">
<memory-budget android:maxMb="32" />
</process>
</processes>
<service
android:name=".playback.AudioPlayerService"
android:foregroundServiceType="mediaPlayback"
android:exported="false" />
<service
android:name=".sync.PlaylistSyncService"
android:process=":sync"
android:exported="false" />
</application>
</manifest>
เมื่อคุณประกาศบล็อก <processes> ในไฟล์ Manifest ให้แสดงรายการ <process> สำหรับกระบวนการที่ประกาศ <memory-budget> เท่านั้น หากต้องการกำหนดงบประมาณเฉพาะกระบวนการย่อยบางรายการเท่านั้น โดยปล่อยให้ส่วนที่เหลือของแอปอยู่ที่ขีดจำกัดของระบบสำหรับอุปกรณ์ คุณสามารถละเว้นองค์ประกอบ <memory-budget> ที่อยู่ใต้ <application> โดยตรงได้
การใช้หน่วยความจำในกระบวนการย่อยจะนับรวมทั้งงบประมาณกระบวนการและงบประมาณแพ็กเกจที่รวมอยู่ด้วย กระบวนการจะพบกับแรงกดดันด้านหน่วยความจำที่รันไทม์หากละเมิดงบประมาณกระบวนการหรืองบประมาณแพ็กเกจ ขึ้นอยู่กับว่าถึงเกณฑ์ใดก่อน
ปรับงบประมาณสำหรับจอแสดงผลที่มีความหนาแน่นสูง
สำหรับแอปที่หน่วยความจำที่ใช้ปรับขนาดอย่างมากตามจำนวนพิกเซลที่ต้องวาดในแต่ละครั้ง เช่น แอปแกลเลอรีรูปภาพที่แคชบิตแมปขนาดเท่ากับหน้าต่าง Android มีกลไกทางเลือก 2 อย่างในการปรับขนาดงบประมาณแบบไดนามิกตามข้อกำหนดการแสดงผล ดังนี้
ปรับขนาดตามที่เก็บความหนาแน่นของการแสดงผล (
android:additionalMbPerDensity): เพิ่มเมกะไบต์ตามสัดส่วนของอัตราส่วนความหนาแน่นของการแสดงผลยกกำลัง 2 สัมพัทธ์กับmdpi(1.0 เท่า/160 dpi) เนื่องจากทรัพยากร UI และทรัพยากรที่วาดได้แบบแรสเตอร์ 2 มิติจะปรับขนาดทั้งความกว้างและความสูง ดังนี้<!-- Baseline 180MB + 16MB multiplied by (density ratio)^2 --> <memory-budget android:maxMb="180" android:additionalMbPerDensity="16" />ในจอแสดงผล
mdpi(1.0 เท่า) บัฟเฟอร์คือ 180 + 16 × 12 = 196 MB ในจอแสดงผลxxhdpi(3.0x) งบประมาณจะปรับเป็น 180 + 16 × 32 = 324 MBปรับขนาดตามจำนวนพิกเซลของหน้าต่าง (
android:additionalBytesPerDisplayPixel): เพิ่มไบต์ต่อพิกเซลในขอบเขตหน้าต่างที่ใช้งานอยู่ (WindowMetrics.getBoundsความกว้าง × ความสูง) ซึ่งเหมาะกับแอปที่จัดสรรพื้นผิวกราฟิกแบบเต็มหน้าต่าง บัฟเฟอร์การแสดงผล หรือแคชรูปภาพความละเอียดสูงที่การใช้หน่วยความจำปรับขนาดตามจำนวนพิกเซลดิบโดยตรง แทนที่จะเป็นบักเก็ตความหนาแน่นของ UI<!-- Baseline 128MB + 16 bytes per window pixel --> <!-- For example, a 4-byte RGBA full-window buffer with double or quadruple buffering --> <memory-budget android:maxMb="128" android:additionalBytesPerDisplayPixel="16" />ในหน้าต่าง 1080p แบบเต็มหน้าจอ (1080 × 2400 ≈ 2.59 ล้านพิกเซล) การดำเนินการนี้จะเพิ่ม 41,472,000 ไบต์ (≈ 39.6 MB โดยที่ 1 MB = 1,048,576 ไบต์) ลงในงบประมาณพื้นฐาน ในหน้าต่าง 1440p (1440 × 3120 ≈ 4.49 ล้านพิกเซล) จะเพิ่ม 71,884,800 ไบต์ (≈ 68.6 MB)
แอตทริบิวต์ 2 รายการนี้เป็นทางเลือก เลือกแอตทริบิวต์ที่ตรงกับค่าตัวคูณมาตราส่วนหลักของแอป และหลีกเลี่ยงการรวมทั้ง 2 อย่างไว้ในส่วนคำสั่งเดียวกัน
ปรับให้เหมาะกับรูปแบบของอุปกรณ์
เมื่อจัดส่ง APK ในโทรศัพท์ แท็บเล็ต และ Wear OS ให้ใช้แอตทริบิวต์ android:feature เพื่อปรับงบประมาณสำหรับเป้าหมายฮาร์ดแวร์ต่างๆ
ในนาฬิกา Wear OS นั้น RAM จะมีจำกัด และ UI รวมถึงชุดฟีเจอร์ของแอปจะเรียบง่ายกว่ามาก คุณสามารถประกาศงบประมาณที่จำกัดมากขึ้นสำหรับฟีเจอร์ watch โดยเฉพาะได้ดังนี้
<!-- General phone and tablet baseline -->
<memory-budget android:maxMb="180" />
<!-- Wear OS override: simpler UI and constrained hardware -->
<memory-budget
android:maxMb="48"
android:feature="watch" />
กฎการแก้ไข: ข้อกำหนดที่เกี่ยวข้องล่าสุดจะมีผล
เมื่อกำหนดองค์ประกอบ <memory-budget> หลายรายการสำหรับแอปหรือกระบวนการ ระบบจะประเมินองค์ประกอบเหล่านั้นตามลำดับที่ปรากฏในไฟล์ Manifest และบังคับใช้ส่วนคำสั่งงบประมาณที่เกี่ยวข้องล่าสุด
android:state ที่ละไว้จะมีค่าเริ่มต้นเป็น foreground ซึ่งจะส่งผลต่อ perceptible และ background ด้วย เว้นแต่จะถูกลบล้างโดยข้อความที่ตามมาสำหรับรัฐเหล่านั้น จัดเรียงส่วนคำสั่งจาก foreground (หรือ android:state ที่ละไว้) เป็น perceptible เป็น background และวางการลบล้าง android:feature ไว้ภายในกลุ่มสถานะที่ตรงกัน เพื่อไม่ให้การลบล้างสถานะที่ละไว้ต่อท้ายบดบังส่วนคำสั่ง perceptible หรือ background ก่อนหน้า
ข้อมูลอ้างอิงแอตทริบิวต์ XML
แอตทริบิวต์เมกะไบต์ (MB) ทั้งหมดใช้หน่วยไบนารี (1 MB = 1,048,576 ไบต์) และแมปกับค่าใช้จ่าย memory.current ของ Linux cgroup (ซึ่งไม่รวมหน่วยความจำที่ใช้ร่วมกันจาก Zygote)
| แอตทริบิวต์ | รูปแบบ | ค่าเริ่มต้น | คำอธิบาย |
|---|---|---|---|
android:maxMb |
จำนวนเต็ม (> 0) | ต้องระบุ | ขีดจำกัดงบประมาณหน่วยความจำที่ใช้จริงพื้นฐานในหน่วย MB |
android:state |
ค่าแจกแจง | foreground |
สถานะกระบวนการที่งบประมาณนี้มีผลบังคับใช้: foreground, perceptible หรือ background หากละเว้น ระบบจะใช้ค่าเริ่มต้นเป็น foreground และส่งต่อค่าไปยัง perceptible และ background เว้นแต่จะถูกลบล้างโดยส่วนคำสั่งที่ตามมา |
android:additionalMbPerDensity |
จำนวนเต็ม (≥ 0) | 0 |
เมกะไบต์เพิ่มเติมคูณด้วยกำลังสองของอัตราส่วนความหนาแน่นของการแสดงผลที่สัมพันธ์กับ mdpi (1.0 เท่า) |
android:additionalBytesPerDisplayPixel |
จำนวนเต็ม (≥ 0) | 0 |
ไบต์เพิ่มเติมที่จัดสรรต่อพิกเซลของหน้าต่าง (WindowMetrics.getBounds ความกว้าง × ความสูง) ซึ่งมีประโยชน์สำหรับบัฟเฟอร์พื้นผิวและบิตแมป |
android:feature |
สตริง | ช่วง | จำกัดส่วนคำสั่งไว้เฉพาะอุปกรณ์ที่ประกาศฟีเจอร์ฮาร์ดแวร์ที่เฉพาะเจาะจง ได้แก่ watch, automotive หรือ leanback |
Runtime API
นอกจากคำสั่ง <memory-budget> manifest ที่ประกาศแล้ว Android ยังมี API ของ SDK รันไทม์สำหรับงานต่อไปนี้ด้วย
- ตรวจสอบงบประมาณที่เป็นไปได้เบื้องหลังการกำหนดค่าระยะไกลก่อนที่จะนำไปใช้กับ
AndroidManifest.xmlตามที่อธิบายไว้ในเผยแพร่งบประมาณเป็นระยะๆ - ค้นหาการใช้งานหน่วยความจำ cgroup แบบเรียลไทม์และงบประมาณที่มีผลในกระบวนการ
- จำกัดงบประมาณของกระบวนการหรือแพ็กเกจแบบไดนามิกในระหว่างงานที่ใช้ทรัพยากรน้อย
- คอยฟังเหตุการณ์ที่เกินงบประมาณเพื่อตัดแคชเมื่อระบบปฏิบัติการเรียกคืนหน่วยความจำ
Android SDK API (MemoryBudgetManager)
บริการระบบ MemoryBudgetManager พร้อมใช้งานสำหรับแอปที่เขียนด้วย Kotlin และ Java ตั้งแต่ Android 17 QPR2 (SDK รุ่นย่อย, ระดับ API 37.2 / Build.VERSION_CODES_FULL.CINNAMON_BUN_2) เป็นต้นไป
ดึงข้อมูลบริการ
ก่อนเข้าถึง MemoryBudgetManager ให้ตรวจสอบว่าอุปกรณ์ใช้ Android 17 QPR2 ขึ้นไปโดยตรวจสอบ SDK_INT_FULL หาก
minSdk ของแอปต่ำกว่า 36 ให้ตรวจสอบ SDK_INT ก่อนเพื่อไม่ให้อุปกรณ์ที่ใช้ Android 15 (ระดับ API 35) หรือต่ำกว่าแสดงข้อผิดพลาด NoSuchFieldError เมื่ออ่าน SDK_INT_FULL:
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.BAKLAVA &&
Build.VERSION.SDK_INT_FULL >= Build.VERSION_CODES_FULL.CINNAMON_BUN_2
) {
val budgetManager = context.getSystemService(MemoryBudgetManager::class.java)
}
การใช้งานการค้นหาและงบประมาณ
// Query current memory charged to this process and the package UID
val processUsageBytes = budgetManager.processCurrentUsageBytes
val packageUsageBytes = budgetManager.packageCurrentUsageBytes
// Query process-scope and package-scope limits (LIMIT_IS_DISABLED if unset)
val processBudgetBytes = budgetManager.processBudgetBytes
val packageBudgetBytes = budgetManager.packageBudgetBytes
ตั้งค่าหรือล้างงบประมาณแบบไดนามิก
คุณสามารถตั้งค่างบประมาณที่เข้มงวดขึ้นขณะรันไทม์เพื่อจำกัดหน่วยความจำระหว่างงานที่มีน้ำหนักเบา หรือล้างหน่วยความจำเมื่องานเสร็จสิ้นได้ ดังนี้
// Set a tighter dynamic budget on the current process (for example, 96 MB)
try {
budgetManager.processBudgetBytes = 96L * 1024L * 1024L
} catch (e: IllegalArgumentException) {
// Thrown if the budget is <= 0 or exceeds a manifest or system limit.
Log.e(TAG, "Requested budget exceeds manifest or system ceiling", e)
}
// Clear the dynamic process budget to restore the manifest limit (or unconstrained baseline)
budgetManager.clearProcessBudget()
ซึ่งแตกต่างจากส่วนคำสั่งไฟล์ Manifest ของ <memory-budget> ที่ระบุขีดจำกัดแยกต่างหากสำหรับสถานะ foreground, perceptible และ background โดยงบประมาณแบบไดนามิกที่ตั้งค่าผ่าน MemoryBudgetManager จะใช้เพดานรันไทม์เดียวจนกว่าโค้ดจะอัปเดตหรือล้างค่า หากคุณใช้รันไทม์ API เพื่อทำการทดสอบภาคสนามหรือจัดการขีดจำกัดเฉพาะสถานะ ให้อัปเดตหรือล้างงบประมาณแบบไดนามิกตลอดการเปลี่ยนวงจร เช่น ผ่าน ProcessLifecycleOwner หรือ Callback ของวงจรกิจกรรม ดังที่แสดงในตัวอย่างเครื่องมือแก้ไขรูปภาพแบบปรับอัตโนมัติ
ประสิทธิภาพและความสามารถในการทำงานซ้ำ
เมื่อทำงานกับ MemoryBudgetManager ขณะรันไทม์ โปรดคำนึงถึงลักษณะต่อไปนี้
- Idempotency: API การเปลี่ยนแปลงงบประมาณทั้งหมดเป็นแบบ Idempotent การเรียกใช้
clearProcessBudget()หรือclearPackageBudget()ซ้ำๆ หรือเมื่อไม่มีงบประมาณแบบไดนามิกที่ใช้งานอยู่เป็นการดำเนินการที่ปลอดภัยและไม่มีผลใดๆ ในทำนองเดียวกัน การตั้งค่าsetProcessBudgetBytes()หรือsetPackageBudgetBytes()เป็นค่าเดียวกันติดต่อกันจะไม่ทริกเกอร์การกำหนดค่าระบบใหม่ที่ซ้ำซ้อน - ความถี่ในการเรียกใช้: การตั้งค่า การอัปเดต หรือการล้างงบประมาณจะทำการเรียกใช้ข้ามกระบวนการไปยังบริการของระบบเพื่ออัปเดตตัวควบคุมหน่วยความจำของระบบปฏิบัติการสำหรับกระบวนการนั้น แม้ว่าจะมีขนาดเล็ก แต่ก็ไม่ได้ไม่มีค่าใช้จ่ายเลย เรียกใช้ API เหล่านี้ในระหว่างการเปลี่ยนวงจรและการบรรลุเป้าหมายของงาน (เช่น การเข้าหรือออกจากกิจกรรม การเริ่มหรือกระบวนการเบื้องหลังเสร็จสมบูรณ์ หรือการจัดการคำขอเสียงพูด) และหลีกเลี่ยงการเรียกใช้ API เหล่านี้ในลูปที่แน่นหนา เทรดการประมวลผลเสียง หรือรูทีนการแสดงผลต่อเฟรม
- ความถี่ในการค้นหา: พร็อพเพอร์ตี้การค้นหา
processCurrentUsageBytes,packageCurrentUsageBytes,processBudgetBytesและpackageBudgetBytesจะอ่านขีดจำกัดและการใช้งาน cgroup แบบเรียลไทม์ในกระบวนการผ่านการเรียกใช้แบบเนทีฟในเครื่อง แทนการเรียกใช้บริการของระบบ แม้ว่าการค้นหาเหล่านี้จะรวดเร็ว แต่ให้เรียกใช้ตามต้องการ (เช่น ระหว่างการเปลี่ยนงานหรือภายใน Callback ของOnOverBudgetListener) แทนที่จะทำการสำรวจในลูปที่จำกัด
ฟัง Callback ของแรงกดดันด้านงบประมาณที่เกิน
แอปสามารถลงทะเบียน Listener เพื่อรับการแจ้งเตือนเมื่อการใช้งานหน่วยความจำเกินเกณฑ์งบประมาณ ซึ่งจะช่วยให้แอปทำการล้างข้อมูลเชิงรุกในระดับแอปได้ (เช่น การล้างแคชบิตแมปในหน่วยความจำ) ขณะที่ระบบปฏิบัติการเรียกคืนหน่วยความจำเพื่อรักษากระบวนการหรือแพ็กเกจให้อยู่ภายในงบประมาณ
val cleanupThread = HandlerThread("MemoryBudgetCleanup").apply { start() }
val listener = MemoryBudgetManager.OnOverBudgetListener { budgetBytes ->
Log.w(TAG, "Process exceeded memory budget of $budgetBytes bytes")
// Proactively evict thread-safe caches on the background Looper
imageTileCache.evictAll()
}
// Register on a background Looper before tightening a dynamic budget
budgetManager.registerProcessOverBudgetListener(cleanupThread.looper, listener)
// When done (for example, in onStop)
budgetManager.unregisterProcessOverBudgetListener(listener)
แนวทางปฏิบัติแนะนำสำหรับการเรียกกลับเมื่อเกินงบประมาณ
- ใช้
Looperในเบื้องหลัง: ส่งLooperในเบื้องหลังHandlerThreadไปยังregisterProcessOverBudgetListenerหรือregisterPackageOverBudgetListenerเมื่อเป็นไปได้ การเรียกใช้การลบแคชหรือการล้างไฟล์ในเธรดเบื้องหลังจะช่วยหลีกเลี่ยงการแย่งชิงทรัพยากรกับการแสดงผลเฟรมในเธรด UI ขณะที่กระบวนการอยู่ภายใต้แรงกดดันด้านหน่วยความจำ สงวนLooper.getMainLooperไว้สำหรับ Listener ที่แตะสถานะ UI ที่เชื่อมโยงกับเทรดหลักเท่านั้น - คาดว่าจะมีการเรียกกลับซ้ำๆ: การเรียกกลับเมื่อเกินงบประมาณไม่ใช่การแจ้งเตือนแบบครั้งเดียว เมื่อการใช้งานเกินงบประมาณ ระบบปฏิบัติการจะเรียกคืนหน้าเว็บที่ไม่มีการใช้งานก่อน และหากยังคงมีแรงกดดัน ระบบจะเรียกคืนหน่วยความจำและเรียกใช้ Listener ของคุณอย่างน้อย 1 ครั้งต่อวินาที ทำให้ Callback เป็นแบบ Idempotent หากแอปต้องการการแจ้งเตือนเพียงครั้งเดียวหรือต้องการระยะเวลาพักนานขึ้นระหว่างการล้างข้อมูล ให้เรียกใช้
unregisterProcessOverBudgetListener(หรือunregisterPackageOverBudgetListener) ภายใน Callback หรือป้องกันการล้างข้อมูลด้วยการประทับเวลาของระยะเวลาพักหรือAtomicBoolean - ลงทะเบียนก่อนจำกัดงบประมาณ: หากการใช้งานหน่วยความจำปัจจุบันเกินงบประมาณใหม่อยู่แล้วเมื่อคุณเรียกใช้
setProcessBudgetBytesหรือsetPackageBudgetBytesระบบจะทริกเกอร์เหตุการณ์งบประมาณเกินทันทีที่มีการใช้งบประมาณใหม่ ลงทะเบียน Listener ก่อนตั้งค่างบประมาณเพื่อให้แอปไม่พลาดการแจ้งเตือนงบประมาณเกินครั้งแรก - ดำเนินการอย่างรวดเร็ว: การดำเนินการเพื่อเรียกคืนต้องให้ความช่วยเหลือทันที การคำนวณที่ซับซ้อนระหว่างที่เกิดแรงกดดันจะทำให้ประสิทธิภาพแย่ลง
- หลีกเลี่ยงการจัดสรร: อย่าจัดสรรออบเจ็กต์ใหม่หรือเริ่มชุดข้อความใหม่ภายใน Callback เนื่องจากอาจทำให้ระบบปฏิบัติการเรียกคืนโดยตรงทันที
- มุ่งเน้นที่เป้าหมายที่ให้ผลตอบแทนสูง: การลบ Bitmap ขนาดใหญ่, บัฟเฟอร์การแสดงผล หรือการปิดไฟล์ที่แมปหน่วยความจำจะมีประสิทธิภาพมากกว่าการปล่อยออบเจ็กต์ขนาดเล็กจำนวนมาก
ตัวอย่าง Runtime API
ตัวอย่างต่อไปนี้แสดงวิธีใช้ Runtime API โดยใช้ Android SDK API ใน Kotlin
ตัวอย่าง Android SDK: เครื่องมือแก้ไขรูปภาพแบบปรับเปลี่ยนได้
ตัวอย่างนี้แสดงแอปแต่งรูป (com.example.imageeditor) ที่ไฟล์ Manifest ประกาศเพดาน 256 MB เพื่อรองรับแคนวาสแบบหลายเลเยอร์
<manifest ... >
<application ... >
<!-- Manifest ceiling accommodates the heaviest editing workload -->
<memory-budget android:maxMb="256" />
</application>
</manifest>
เมื่อผู้ใช้เรียกดูแกลเลอรีภาพขนาดย่อที่มีน้ำหนักเบา แอปจะใช้ API ของ Android SDK ใน Kotlin เพื่อลดงบประมาณกระบวนการลงเหลือ 96 MB แบบไดนามิก
เมื่อผู้ใช้เปิดพื้นที่ทำงานการแก้ไขแบบหลายเลเยอร์ แอปจะล้างงบประมาณแบบไดนามิกเพื่อคืนค่าเพดานไฟล์ Manifest ขนาด 256 MB เต็ม นอกจากนี้ยังลงทะเบียน OnOverBudgetListener ใน HandlerThread เบื้องหลังLooper ก่อนที่จะใช้งบประมาณแกลเลอรีเพื่อลบบิตแมปตัวอย่างที่แคชไว้ภายใต้แรงกดดันโดยไม่บล็อกเธรด UI
package com.example.imageeditor.ui
import android.app.Activity
import android.app.MemoryBudgetManager
import android.graphics.Bitmap
import android.os.Bundle
import android.os.HandlerThread
import android.util.Log
import android.util.LruCache
class ImageEditorActivity : Activity() {
private lateinit var budgetManager: MemoryBudgetManager
private lateinit var cleanupThread: HandlerThread
// Thread-safe in-memory cache for rendered preview tiles (32MB limit)
private val previewCache = object : LruCache<String, Bitmap>(32 * 1024 * 1024) {
override fun sizeOf(key: String, value: Bitmap): Int = value.byteCount
}
private val overBudgetListener = MemoryBudgetManager.OnOverBudgetListener { budgetBytes ->
Log.w(TAG, "Process memory pressure detected (budget: ${budgetBytes / 1048576}MB). Evicting preview cache.")
previewCache.evictAll()
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
budgetManager = getSystemService(MemoryBudgetManager::class.java)
cleanupThread = HandlerThread("MemoryBudgetCleanup").apply { start() }
}
override fun onStart() {
super.onStart()
// Register listener on a background Looper before tightening the budget
budgetManager.registerProcessOverBudgetListener(cleanupThread.looper, overBudgetListener)
// Constrain memory during lightweight gallery browsing
applyGalleryBudget()
}
override fun onStop() {
super.onStop()
budgetManager.unregisterProcessOverBudgetListener(overBudgetListener)
// Clear the activity-scoped gallery budget when leaving the activity.
budgetManager.clearProcessBudget()
}
override fun onDestroy() {
cleanupThread.quitSafely()
super.onDestroy()
}
/**
* Called when the user enters the high-resolution editing canvas.
* Clears the dynamic budget, restoring the full 256MB manifest ceiling.
*/
fun enterEditingCanvas() {
// Clear the tighter dynamic budget to restore the full manifest ceiling (256MB)
budgetManager.clearProcessBudget()
Log.i(TAG, "Restored manifest budget ceiling (256MB) for editing canvas")
}
/**
* Called when the user exits the editor back to the thumbnail gallery.
* Re-applies the tighter dynamic budget.
*/
fun exitToGallery() {
previewCache.trimToSize(8 * 1024 * 1024)
applyGalleryBudget()
}
private fun applyGalleryBudget() {
try {
// Dynamically tighten budget to 96MB for the lightweight gallery view
budgetManager.processBudgetBytes = 96L * 1024L * 1024L
Log.i(TAG, "Tighter dynamic budget applied for gallery: 96MB")
} catch (e: IllegalArgumentException) {
Log.e(TAG, "Could not apply dynamic budget", e)
}
}
companion object {
private const val TAG = "ImageEditor"
}
}
ปรับเทียบ ทดสอบ และจัดสรรงบประมาณ
การใช้บัดเจ็ตหน่วยความจำอย่างถูกต้องมี 3 ขั้นตอนดังนี้
- ปรับเทียบงบประมาณสำหรับสถานะกระบวนการแต่ละสถานะ
- ทดสอบอย่างละเอียดก่อนเผยแพร่
- เปิดตัวเป็นระยะๆ: ตรวจสอบความถูกต้องเบื้องหลังการกำหนดค่าระยะไกล นำไปใช้ในไฟล์ Manifest และวัดผลต่อไป
ปรับเทียบงบประมาณ
งบประมาณที่ดีควรอยู่เหนือชุดการทำงานของแอปสำหรับสถานะหนึ่งๆ เล็กน้อย ไม่ใช่ที่จุดสูงสุดที่ไม่มีข้อจำกัด หากต้องการหาจุดนั้น ให้เรียกใช้โฟลว์ผู้ใช้ที่สมจริง ลดงบประมาณทีละขั้น และคอยดูช่วงเวลาที่แอปเริ่มจ่ายเงินสำหรับงบประมาณนั้น
ทำความเข้าใจชุดการทำงานเทียบกับหน่วยความจำที่ใช้จริง
หากไม่มีงบประมาณ ฟุตพริ้นท์ที่แอปใช้ (memory.current) จะเก็บหน่วยความจำ 2 ประเภท ได้แก่
- ชุดการทำงาน: Java, Kotlin และฮีปแบบเนทีฟ รวมถึงหน้าที่มีการเข้าถึงบ่อยซึ่งมีไฟล์สำรอง (โค้ด DEX, ไลบรารีแบบเนทีฟ และชิ้นงาน) ที่โฟลว์ผู้ใช้ปัจจุบันเข้าถึงซ้ำๆ
- Cold slack: แคชบิตแมปจากหน้าจอก่อนหน้า, บัฟเฟอร์การเริ่มต้นแบบครั้งเดียว, Heap slack ที่เหลืออยู่หลังจากการจัดสรรแบบต่อเนื่อง และหน้าไฟล์ที่อ่านครั้งเดียวและไม่เคยแตะอีกเลย
งบประมาณที่จุดสูงสุดแบบไม่จำกัดจะไม่เรียกคืนทรัพยากรที่ไม่ได้ใช้งาน งบประมาณที่ต่ำกว่าชุดการทำงานจะทำให้เคอร์เนลสลับหน้าฮีปออกและนำหน้าโค้ดที่แอปของคุณทำให้เกิดข้อผิดพลาดทันทีออก การดึงข้อมูลชุดการทำงานซ้ำเหล่านี้ใช้เวลา CPU และแบตเตอรี่ และเมื่อไปถึงเธรด UI ก็จะใช้เฟรมด้วย
สิ่งที่คุณกำลังมองหาคือจุดหักเห ซึ่งก็คือจุดที่งบประมาณต่ำสุดที่การเรียกคืนจะนำเฉพาะส่วนที่ไม่ได้ใช้งานออก ดังนั้นข้อบกพร่องซ้ำ เวลา CPU และเวลาที่ใช้ในการแสดงผลเฟรมจะยังคงเหมือนเดิมโดยไม่มีงบประมาณ
เตรียมสภาพแวดล้อมการทดสอบ
ตั้งค่าการทดสอบที่ทำซ้ำได้ซึ่งทำงานเหมือนเวอร์ชันที่ใช้งานจริง โดยทำดังนี้
- ปรับเทียบกับบิลด์ที่เผยแพร่ซึ่งเพิ่มประสิทธิภาพด้วย R8 และแก้ไขข้อบกพร่องไม่ได้แบบเดียวกับที่คุณจัดส่ง บิลด์การแก้ไขข้อบกพร่องใช้หน่วยความจำมากกว่า ดังนั้นงบประมาณที่ปรับแต่งในบิลด์การแก้ไขข้อบกพร่องจึงสูงเกินไปสำหรับการเผยแพร่
- ทดสอบในอุปกรณ์หรือโปรแกรมจำลองที่ใช้ Android 17 QPR2 (ระดับ API 37.2) ขึ้นไป บิลด์
userdebugหรืออิมเมจโปรแกรมจำลองที่ไม่มี Google Play จะสะดวกเมื่อสุ่มตัวอย่างไฟล์ cgroup จากadb shellเนื่องจากการอ่านไดเรกทอรี cgroup ของแอปจาก Shell อาจต้องใช้adb rootแอปสามารถอ่านการใช้งาน cgroup ของกระบวนการของตนเองในกระบวนการผ่านMemoryBudgetManagerได้แม้ในบิลด์เวอร์ชันที่ใช้งานจริง - เขียนสคริปต์โฟลว์ผู้ใช้ 30 ถึง 60 วินาทีด้วย Jetpack Macrobenchmark, UI Automator หรือ
adb shell input1 ครั้งสำหรับแต่ละสถานะที่คุณวางแผนจะกำหนดงบประมาณ แอปที่ไม่มีการใช้งานจะไม่บอกข้อมูลใดๆ เกี่ยวกับชุดการทำงานของแอปforeground: เลื่อนรายการที่หนาแน่นและตารางกริดสื่อ ย้ายไปมาระหว่างปลายทางหลัก เปิดเมนูและกล่องโต้ตอบ และเรียกใช้ภาพเคลื่อนไหวperceptible: ออกจากหน้าต่างที่มองเห็นได้ขณะที่การทำงานที่รับรู้ได้ยังคงดำเนินต่อไป (เช่น การเล่นเสียงหรือการดาวน์โหลด) ปล่อยให้ทำงานเป็นเวลา 10-15 วินาที แล้วกลับไปที่แอปbackground: ทริกเกอร์การซิงค์, งานWorkManager(เช่น ด้วยadb shell cmd jobscheduler run -f <package-name> <job-id>), บริการที่เริ่มต้น หรือ Broadcast Receiver ขณะที่แอปไม่มี UI ที่มองเห็นได้
วัดงบประมาณ background ขณะที่งานเบื้องหลังกำลังทำงานอยู่ แทนที่จะวัดขณะที่กระบวนการไม่มีการใช้งานในสถานะแคช (IMPORTANCE_CACHED) แม้ว่างบประมาณ background จะยังคงมีผลขณะแคชอยู่ แต่กระบวนการแคชที่ไม่มีการใช้งานจะไม่ทำงานเบื้องหลังและไม่แสดงชุดการทำงานของงานเบื้องหลังหรือตัวรับสัญญาณ
วัดค่าพื้นฐาน
เริ่มต้นด้วยการเรียกใช้ที่ไม่มีงบประมาณเลย เพื่อให้คุณทราบว่าการทำงานปกติเป็นอย่างไร
ใช้บิลด์ที่ไม่มีการประกาศ <memory-budget> และเริ่มการเรียกใช้แต่ละครั้งจากกระบวนการใหม่ (adb shell am force-stop <package-name>)
กระบวนการของแอปแต่ละรายการมีตัวควบคุมหน่วยความจำ cgroup v2 ของตัวเอง ค้นหาเส้นทางจากบรรทัด 0:: ของ /proc/<PID>/cgroup แทนการฮาร์ดโค้ดเส้นทาง ส่งคำสั่งอุปกรณ์แต่ละรายการไปยัง adb shell เป็นสตริงที่อยู่ในเครื่องหมายคำพูดเดียว เพื่อให้เชลล์ของอุปกรณ์เห็นเครื่องหมายคำพูด ดังนี้
PID=$(adb shell pidof -s <package-name>)CG=/sys/fs/cgroup$(adb shell "sed -n 's/^0:://p' /proc/$PID/cgroup")adb shell "cat $CG/memory.current $CG/memory.swap.current"adb shell "grep -E '^(anon|file|workingset_refault_.*) ' $CG/memory.stat"
การอ่านไฟล์เหล่านี้ใช้ทรัพยากรน้อยและไม่รบกวนแอป คุณจึงสุ่มตัวอย่างไฟล์เหล่านี้ได้ทุกวินาทีระหว่างการเรียกใช้
memory.current: หน่วยความจำที่ใช้จริงซึ่งเรียกเก็บจากกระบวนการ (หน่วยเป็นไบต์) ซึ่งเป็นจำนวนที่<memory-budget>จำกัดไว้memory.swap.current: หน่วยความจำที่บีบอัดเป็น zRAM swap ในหน่วยไบต์anonและfileในmemory.stat: หน่วยความจำแบบไม่ระบุตัวตนและแบบมีไฟล์สำรองในหน่วยความจำหลัก (หน่วยเป็นไบต์)workingset_refault_anonและworkingset_refault_fileในmemory.stat: จำนวนหน้าเว็บที่สลับออกหรือถูกขับออกซึ่งแอปของคุณต้องการอีกครั้ง ตัวนับเหล่านี้เป็นสัญญาณหลักที่บ่งบอกว่างบประมาณมีจำกัดเกินไป
หากคุณได้รับข้อผิดพลาดเกี่ยวกับสิทธิ์เมื่ออ่านไฟล์ cgroup ของแอปจาก adb
shell ให้เรียกใช้ adb root ในบิลด์ userdebug หรืออิมเมจโปรแกรมจำลองที่ไม่มี Google Play แล้วลองอีกครั้ง ในบิลด์เวอร์ชันที่ใช้งานจริง user ซึ่ง adb root ไม่พร้อมใช้งาน ให้ค้นหา MemoryBudgetManager.processCurrentUsageBytes จากภายในแอป หรือใช้ adb shell dumpsys meminfo <package-name> เพื่อดูมุมมองที่กว้างขึ้น
ใน App Summary, Java Heap, Native Heap และ Stack ส่วนใหญ่จะเป็นหน่วยความจำแบบไม่ระบุตัวตน และ Code จะเป็นหน่วยความจำที่สำรองข้อมูลไว้ในไฟล์ บิตแมปซอฟต์แวร์จะนับรวมใน Native Heap และงบประมาณของคุณ ส่วนบิตแมปฮาร์ดแวร์และ Graphics จะไม่นับรวม อย่าเรียกใช้ dumpsys meminfo ในลูปขณะวัดเวลาที่ใช้ในการแสดงผลเฟรม เนื่องจากจะบังคับให้มีการเก็บขยะในแอปและตรวจสอบการแมปหน่วยความจำทั้งหมด ซึ่งจะเปลี่ยนสิ่งที่คุณพยายามวัด
กวาดงบประมาณของผู้สมัคร
คุณสามารถลองใช้งบประมาณที่เป็นไปได้โดยไม่ต้องสร้างแอปใหม่ ใช้ am memory-limiter manual เพื่อกำหนดงบประมาณสำหรับกระบวนการที่ทำงานอยู่ และใช้ none เพื่อนำงบประมาณออก ดังนี้
adb shell am memory-limiter manual <PID> 120MBadb shell am memory-limiter manual <PID> none
การลบล้างด้วยตนเองจะคงอยู่ตลอดอายุการใช้งานของอินสแตนซ์กระบวนการนั้นๆ ในการเปลี่ยนแปลงสถานะกระบวนการ ดังนั้นให้ล้างหรือรีสตาร์ทกระบวนการก่อนดำเนินการต่อ
นอกจากนี้ยังตั้งค่าขีดจำกัดสูงสุดของกระบวนการ (memory.max) เป็นค่าเดียวกันด้วย ดังนั้นงบประมาณที่เป็นไปได้ซึ่งต่ำกว่าชุดการทำงานของแอปอาจทำให้กระบวนการถูกหยุดแทนที่จะแค่ช้าลง ให้ถือว่างบประมาณดังกล่าวไม่สำเร็จ
นอกจากนี้ คุณยังกวาดค่าจากบิลด์การเปรียบเทียบได้โดยการอ่านค่าที่เป็นไปได้จากอาร์กิวเมนต์การวัดและตั้งค่า MemoryBudgetManager.processBudgetBytes งบประมาณรันไทม์สามารถจำกัดงบประมาณไฟล์ Manifest ได้เท่านั้น ดังนั้นให้กวาดล้างบิลด์ที่ไม่มีการประกาศ <memory-budget> นอกจากนี้ยังคงมีผลบังคับใช้ตลอดการเปลี่ยนแปลงสถานะกระบวนการจนกว่าคุณจะเรียกใช้ clearProcessBudget
เริ่มที่ memory.current สูงสุดจากเกณฑ์พื้นฐาน แล้วลดลงครั้งละ 10-15 MB สำหรับงบประมาณที่เป็นไปได้แต่ละรายการ ให้ทำดังนี้
- เริ่มกระบวนการใหม่ นำกระบวนการเข้าสู่สถานะเป้าหมาย และใช้งบประมาณ
- เรียกใช้โฟลว์ผู้ใช้ 1 ครั้งเพื่อเป็นการเตรียมพร้อม การใช้งบประมาณจะขับหน้า Cold Startup ออกไป 1 ครั้ง และคุณต้องการวัดสถานะคงที่มากกว่าการเปลี่ยนผ่านนั้น
รีเซ็ตสถิติเฟรม และบันทึกตัวนับการเกิดข้อผิดพลาดซ้ำเริ่มต้นและเวลา CPU ของกระบวนการ (
utimeและstimeในหน่วยขีดสัญญาณนาฬิกา)adb shell dumpsys gfxinfo <package-name> resetadb shell "grep -E '^workingset_refault_(anon|file) ' $CG/memory.stat"adb shell "cut -d ' ' -f 14,15 /proc/$PID/stat"เรียกใช้การส่งที่วัดผลของโฟลว์ผู้ใช้
บันทึก
memory.current,anon,file, ตัวนับข้อผิดพลาดซ้ำ และเวลา CPU อีกครั้ง แล้วรวบรวมสถิติเฟรมdumpsys gfxinfoสามารถพิมพ์สถิติเดียวกันได้มากกว่า 1 ครั้ง ดังนั้นให้ใช้รายการแรกที่ตรงกันซึ่งครอบคลุมทั้งแอป ดังนี้adb shell "dumpsys gfxinfo <package-name>" | grep -m 1 'Janky frames:'adb shell "dumpsys gfxinfo <package-name>" | grep -m 1 '95th percentile'
ทำซ้ำผู้สมัครแต่ละรายอย่างน้อย 3 ครั้ง และสลับผู้สมัครแทนที่จะเรียกใช้การทำซ้ำทั้งหมดของผู้สมัครรายเดียวแบบต่อเนื่องกัน เปรียบเทียบผลลัพธ์แต่ละรายการกับการกระจายของการเรียกใช้พื้นฐาน ไม่ใช่การเรียกใช้ครั้งเดียว
อ่านผลลัพธ์
เมื่อโควต้าลดลง แอปจะเข้าสู่ 3 ระบอบการปกครองดังนี้
- เหนือขีดจำกัด:
memory.currentจะลดการใช้หน่วยความจำตามงบประมาณโดยการกำจัดหน้าfileที่ไม่ได้ใช้งานและฮีปที่ไม่มีการใช้งานanonคงที่ การเกิดข้อผิดพลาดซ้ำยังคงอยู่ใกล้กับเส้นฐาน และเวลา CPU และเวลาที่ใช้ในการแสดงผลเฟรมไม่เปลี่ยนแปลง นี่คือที่ที่คุณต้องการอยู่ - ต่ำกว่าระดับที่เหมาะสม: หน้าเว็บที่ไม่มีการใช้งานหายไป เคอร์เนลจึงเริ่มสลับหน้าฮีปที่แอปยังคงใช้อยู่ Refault จะเพิ่มขึ้นหลายร้อยหรือหลายพันหน้าต่อการเรียกใช้แต่ละครั้ง และเวลา CPU จะเพิ่มขึ้น เวลาที่ใช้ในการแสดงผลเฟรมอาจแทบไม่เปลี่ยนแปลงในอุปกรณ์ทดสอบที่ไม่มีการใช้งาน แต่ตอนนี้แอปของคุณใช้เวลา CPU และแบตเตอรี่ในการบีบอัดและคลายการบีบอัดชุดการทำงานของตัวเอง
- ต่ำกว่าระดับที่เหมาะสมมาก: ข้อผิดพลาดในการเรียกคืนและสลับเข้าจะเกิดขึ้นในเธรด UI และ
RenderThreadรวมถึงอาการกระตุก เวลาที่ใช้ในการแสดงผลเฟรม และเวลาในการกลับมาทำงานแบบวอร์มรีซูมจะเพิ่มขึ้นทั้งหมด
เมื่อเทียบกับเกณฑ์พื้นฐานที่ไม่มีข้อจำกัด งบประมาณที่เป็นไปได้จะผ่านเกณฑ์หากเป็นไปตามเงื่อนไขต่อไปนี้ทั้งหมด ซึ่งเป็นจุดเริ่มต้นที่สมเหตุสมผล
- กระบวนการจะยังคงอยู่หลังจากการเรียกใช้
- เดลต้าเริ่มต้นใหม่ยังคงใกล้เคียงกับค่าพื้นฐาน
- เวลา CPU ของกระบวนการเพิ่มขึ้นไม่เกิน 5%
- เฟรมที่กระตุกเพิ่มขึ้นไม่เกิน 1 เปอร์เซ็นต์
- เวลาที่ใช้ในการแสดงผลเฟรม P95 เพิ่มขึ้นไม่เกิน 3 มิลลิวินาที
- เวลาในการกลับมาทำงานอีกครั้งแบบวอร์ม (
TotalTimeจากadb shell am start -W) เพิ่มขึ้นไม่เกิน 15% สำหรับงบประมาณperceptibleและbackground
จุดหักเหคืองบประมาณที่เป็นไปได้ต่ำสุดที่ผ่านเกณฑ์ ตัวอย่างเช่น ต่อไปนี้คือการกวาดล้างเบื้องหน้าสำหรับแอปสมมติที่มีจุดสูงสุดแบบไม่จำกัดที่ 138 MB
| งบประมาณที่เป็นไปได้ | memory.current |
anon |
file |
การเกิดข้อผิดพลาดซ้ำ (หน้า) | เวลาที่ใช้ในการแสดงผลเฟรม P95 | Regime |
|---|---|---|---|---|---|---|
| ไม่มี | 138 MB | 75 MB | 63 MB | 0 | 10.5 มิลลิวินาที | เกณฑ์พื้นฐาน |
| 125 MB | 121 MB | 74 MB | 47 MB | 10 | 10.5 มิลลิวินาที | เหนือเข่า |
| 110 MB | 110 MB | 75 MB | 35 MB | 15 | 10.8 มิลลิวินาที | เข่า |
| 95 MB | 95 MB | 74 MB | 21 MB | 176 | 11.2 มิลลิวินาที | ยาวเลยเข่า |
| 85 MB | 85 MB | 68 MB | 17 MB | 2,050 | 12.8 มิลลิวินาที | ยาวเลยเข่า |
| 70 MB | 70 MB | 54 MB | 16 MB | 8,771 | 16.5 มิลลิวินาที | ยาวเลยเข่ามาก |
เลือกงบประมาณ
ตั้งค่า android:maxMb ให้สูงกว่าจุดเปลี่ยน 10% ถึง 20% เพื่อให้ความแตกต่างในข้อมูลผู้ใช้ ภาษา และการจัดสรรที่เพิ่มขึ้นอย่างรวดเร็วไม่ทำให้แอปของคุณต่ำกว่าจุดเปลี่ยน ในตัวอย่างก่อนหน้านี้ จุดหักเหอยู่ที่ 110 MB ดังนั้น 125 MB จึงเป็นตัวเลือกที่ดี
จากนั้นติดตั้งบิลด์ที่เผยแพร่ซึ่งมีการประกาศ <memory-budget> ใหม่ เรียกใช้โฟลว์ผู้ใช้อีกครั้ง และตรวจสอบว่ายังคงเป็นไปตามเกณฑ์การผ่าน หากต้องการยืนยันงบประมาณที่ใช้งานอยู่ในรันไทม์ ให้ค้นหา MemoryBudgetManager.processBudgetBytes หรือ MemoryBudgetManager.packageBudgetBytes
ตรวจสอบงบประมาณที่ไม่ใช่เบื้องหน้าด้วยการคืนค่าแบบวอร์ม
งบประมาณที่จำกัด perceptible หรือ background อาจดูเหมือนไม่มีปัญหาขณะที่แอปอยู่ในสถานะนั้น แต่จะทำให้คุณเสียค่าใช้จ่ายเมื่อผู้ใช้กลับมา ทดสอบการเดินทางขากลับด้วย
- เรียกใช้โฟลว์เบื้องหน้า ย้ายแอปไปยังสถานะเป้าหมาย และใช้งบประมาณที่เป็นไปได้ด้วย
am memory-limiter manual - ปล่อยให้งานที่รับรู้ได้หรือที่ทำงานอยู่เบื้องหลังทำงานเป็นเวลา 10-15 วินาที
- ล้างการลบล้าง (
adb shell am memory-limiter manual <PID> none) แล้วนำแอปกลับมาทันทีด้วยadb shell am start -WและบันทึกTotalTimeหากคุณตั้งค่าผู้สมัครผ่านMemoryBudgetManagerแทน ให้เรียกใช้clearProcessBudgetก่อนที่แอปจะแสดงผล - เรียกใช้การโต้ตอบในเบื้องหน้าสั้นๆ และตรวจสอบข้อผิดพลาดซ้ำและสถิติเฟรมเทียบกับเกณฑ์การผ่าน
เลือกงบประมาณต่ำสุดที่ผ่านทั้ง 2 เกณฑ์ขณะที่แอปอยู่ในสถานะนั้นและเมื่อกลับมาทำงานแบบวอร์ม และเพิ่มส่วนเผื่อ 10% ถึง 20% เช่นเดียวกัน
ปรับเทียบการปรับขนาดการแสดงผล
หากคุณใช้ android:additionalBytesPerDisplayPixel ให้ค้นหาจุดเปลี่ยนของโฟร์กราวด์บนจอแสดงผล 2 จอที่มีความละเอียดต่างกัน เช่น 1080 × 2400 (ประมาณ 2.59 ล้านพิกเซล) และ 1440 × 3120 (ประมาณ 4.49 ล้านพิกเซล)
หารความแตกต่างระหว่างจุดหักเหทั้ง 2 จุด (หน่วยเป็นไบต์) ด้วยความแตกต่างของจำนวนพิกเซลเพื่อให้ได้ android:additionalBytesPerDisplayPixel ลบจำนวนต่อพิกเซลสำหรับจอแสดงผลขนาดเล็กออกจากจุดหักเหเพื่อให้ได้ฐานที่ไม่ขึ้นอยู่กับความละเอียด และเพิ่มเฮดรูมเพื่อให้ได้ android:maxMb
ทดสอบงบประมาณ
ก่อนที่จะเผยแพร่งบประมาณใหม่หรืองบประมาณที่เข้มงวดขึ้น โปรดตรวจสอบสิ่งต่อไปนี้
- บิลด์ที่เผยแพร่: ทดสอบบิลด์ที่คุณจัดส่งตามที่อธิบายไว้ในเตรียมสภาพแวดล้อมการทดสอบ
- สถานะที่มีงบประมาณทั้งหมด: เรียกใช้โฟลว์ที่ทำงานอยู่เบื้องหน้า โฟลว์ที่รับรู้ได้ และโฟลว์ที่ทำงานอยู่เบื้องหลัง และตรวจสอบการกลับมาทำงานแบบอุ่นสำหรับงบประมาณที่ไม่ใช่เบื้องหน้าแต่ละรายการ
- อุปกรณ์ที่มี RAM ต่ำ: รวมอุปกรณ์อย่างน้อย 1 เครื่องจากระดับ RAM ต่ำสุดที่รองรับ
- ขนาดหน้าต่าง: หากคุณใช้
android:additionalBytesPerDisplayPixelให้ทดสอบหน้าต่างแบบแยกหน้าจอและปรับขนาดได้ รวมถึงแบบเต็มหน้าจอ เนื่องจากระบบจะคำนวณงบประมาณที่ปรับขนาดจากขนาดหน้าต่างของแอป - ข้อมูลที่สมจริง: ทดสอบกับบัญชีขนาดใหญ่ รายการที่ยาว และรายการสื่อจำนวนมาก รวมถึงภาษาที่คุณจัดส่ง เนื่องจากชุดการทำงานจะเพิ่มขึ้นตามข้อมูลที่เพิ่มเข้ามา
- แอปแบบหลายกระบวนการ: ดำเนินการแต่ละกระบวนการที่มีส่วนคำสั่ง
<memory-budget>ของตัวเอง - เกตการถดถอย: เรียกใช้การทดสอบการเริ่มต้นและการกระตุกของ Macrobenchmark ที่มีอยู่โดยมีและไม่มีงบประมาณ และทำให้การทดสอบไม่ผ่านหากการเรียกใช้ที่มีงบประมาณถดถอยเกินเกณฑ์การผ่าน
จัดสรรงบประมาณเป็นระยะๆ
งบประมาณรันไทม์ที่ตั้งค่าผ่าน MemoryBudgetManager จะจำกัดขีดจำกัดภายในเพดานไฟล์ Manifest <memory-budget> ที่ประกาศไว้ให้เข้มงวดขึ้นเท่านั้น ไม่สามารถเพิ่มงบประมาณที่ระบุในไฟล์ Manifest ขณะรันไทม์ได้ อย่าจัดส่งค่า <memory-budget> ที่เข้มงวดใน AndroidManifest.xml และวางแผนที่จะผ่อนปรนค่าเหล่านั้นจากแฟล็กเซิร์ฟเวอร์ แต่ให้ปล่อยงบประมาณใหม่เป็น 2 ระยะ ดังนี้
- ตรวจสอบเบื้องหลังการกำหนดค่าระยะไกล: จัดส่ง APK ที่มีเพดานความปลอดภัย
<memory-budget>ที่กว้างเพียงรายการเดียวและไม่มีส่วนคำสั่งperceptibleหรือbackground(แนะนำ) หรือไม่มี<memory-budget>กำหนดงบประมาณที่เป็นไปได้ไว้เบื้องหลังการทดสอบฝั่งเซิร์ฟเวอร์หรือแฟล็กการกำหนดค่าระยะไกล และใช้งบประมาณของสถานะเป้าหมายในการเปลี่ยนผ่านวงจร เช่น ผ่านProcessLifecycleOwnerCatchIllegalArgumentExceptionซึ่งจะแสดงขึ้นเมื่อบัดเจ็ตเวลาในการรันของการทดสอบเกินเพดานไฟล์ Manifest แบบคงที่หรือแบบปรับขนาดหน้าต่าง หรือขีดจำกัดหน่วยความจำของระบบในอุปกรณ์ที่มี RAM ต่ำ ในบล็อกcatchให้เรียกใช้clearProcessBudgetหรือclearPackageBudgetเพื่อให้งบประมาณรันไทม์ที่เข้มงวดขึ้นจากสถานะก่อนหน้าไม่ทำงาน เปรียบเทียบกลุ่มทดสอบตามระดับ RAM ของอุปกรณ์ในเมตริกที่งบประมาณสามารถเปลี่ยนแปลงได้ เช่น เวลาที่ใช้ในการแสดงผลเฟรม เวลาเริ่มต้นและเวลาที่ใช้ในการกลับมาทำงานอีกครั้ง เวลา CPU และแบตเตอรี่ - ย้ายงบประมาณที่ได้รับการพิสูจน์แล้วไปยังไฟล์ Manifest: หลังจากข้อมูลภาคสนามแสดงให้เห็นว่างบประมาณที่เป็นไปได้เป็นไปตามเกณฑ์การผ่านในระดับ RAM ของอุปกรณ์ ให้ย้ายงบประมาณ
foreground,perceptibleและbackgroundในสภาวะคงที่ไปยังส่วนคำสั่ง<memory-budget>เผยแพร่เวอร์ชันนั้นเป็นระยะๆ และดูเมตริกเดียวกัน
ในระหว่างการตรวจสอบรันไทม์ แฟล็กการกำหนดค่าระยะไกลจะเป็น Kill Switch
เมื่อคุณปิดแฟล็ก กระบวนการที่เริ่มใหม่จะข้ามการตั้งค่างบประมาณรันไทม์ และการเรียกใช้ clearProcessBudget หรือ clearPackageBudget จะล้างงบประมาณรันไทม์ที่ใช้งานอยู่ในกระบวนการที่ทำงานอยู่ แอปของคุณจะกลับไปใช้เพดานความปลอดภัยตามไฟล์ Manifest หรือไม่มีงบประมาณแอปหากคุณไม่ได้ประกาศไว้ โดยไม่มีการอัปเดตแอป
เก็บ Flag นี้ไว้ในการกำหนดค่าแอปและเซิร์ฟเวอร์ของคุณเอง แทนที่จะพึ่งพาอุปกรณ์หรือระบบปฏิบัติการเพื่อปิดงบประมาณ
ถือว่างบประมาณที่ตั้งไว้เฉพาะในรันไทม์เป็นขั้นตอนการเปิดตัวชั่วคราว งบประมาณที่ระบุในไฟล์ Manifest จะจัดส่งภายใน APK ที่ลงชื่อแล้วและมีผลตั้งแต่การเริ่มต้นกระบวนการโดยไม่มีโค้ดแอป นอกจากนี้ คุณยังตรวจสอบได้โดยไม่ต้องเรียกใช้แอปด้วยการเรียกใช้ PackageManager.getMemoryBudgets ซึ่งจะอ่านเฉพาะการประกาศ <application> แบบคงที่ การเพิ่มงบประมาณในไฟล์ Manifest ในภายหลังต้องมีการอัปเดตแอป แต่คุณยังคงทำการทดสอบที่ลดงบประมาณในรันไทม์ให้ต่ำกว่าเพดานในไฟล์ Manifest ได้