รองรับหน้าขนาด 16 KB

ที่ผ่านมา Android รองรับหน้าหน่วยความจำขนาด 4 KB เท่านั้น ซึ่งมี เพิ่มประสิทธิภาพหน่วยความจำของระบบสำหรับปริมาณหน่วยความจำทั้งหมดโดยเฉลี่ย อุปกรณ์ Android ที่มักมีในระบบ AOSP รองรับตั้งแต่ Android 15 เป็นต้นไป อุปกรณ์ที่มีการกำหนดค่าให้ใช้หน้าขนาด 16 KB (16 KB) อุปกรณ์) หากแอปใช้ไลบรารี NDK โดยตรงอย่างใดอย่างหนึ่ง หรือโดยอ้อมผ่าน SDK คุณจะต้องสร้างแอปใหม่เพื่อ ใช้ได้กับอุปกรณ์ขนาด 16 KB เหล่านี้

เนื่องจากผู้ผลิตอุปกรณ์ยังคงผลิตอุปกรณ์จำนวนมาก หน่วยความจำกายภาพ (RAM) อุปกรณ์จำนวนมากจะใช้ 16 KB (และ และใหญ่ขึ้น) เพื่อเพิ่มประสิทธิภาพของอุปกรณ์ กำลังเพิ่ม การรองรับอุปกรณ์ขนาดหน้า 16 KB จะช่วยให้แอปของคุณทํางานบนอุปกรณ์เหล่านี้ได้ อุปกรณ์และช่วยให้แอปของคุณได้รับประโยชน์จากประสิทธิภาพที่เกี่ยวข้อง เพิ่มขึ้น หากไม่ทำการคอมไพล์ซ้ำ แอปอาจไม่ทำงานในอุปกรณ์ขนาด 16 KB เมื่อเวอร์ชันที่ใช้งานจริงใน Android รุ่นต่อๆ ไป

เราได้ให้คำแนะนำเกี่ยวกับวิธีตรวจสอบ หากแอปได้รับผลกระทบ วิธีการ สร้างแอปอีกครั้ง (หากมี) และวิธีทดสอบแอปใน สภาพแวดล้อมขนาด 16 KB โดยใช้เครื่องมือจำลอง (รวมถึง Android 15 อิมเมจระบบสำหรับ Android Emulator)

ประโยชน์ที่ได้รับและประสิทธิภาพ

Devices configured with 16 KB page sizes use slightly more memory on average, but also gain various performance improvements for both the system and apps:

  • Lower app launch times while the system is under memory pressure: 3.16% lower on average, with more significant improvements (up to 30%) for some apps that we tested
  • Reduced power draw during app launch: 4.56% reduction on average
  • Faster camera launch: 4.48% faster hot starts on average, and 6.60% faster cold starts on average
  • Improved system boot time: improved by 1.5% (approximately 0.8 seconds) on average

These improvements are based on our initial testing, and results on actual devices will likely differ. We'll provide additional analysis of potential gains for apps as we continue our testing.

ตรวจสอบว่าแอปของคุณได้รับผลกระทบหรือไม่

If your app uses any native code, then you should rebuild your app with support for 16 KB devices. If you are unsure if your app uses native code, you can use the APK Analyzer to identify whether any native code is present.

If your app only uses code written in the Java programming language or in Kotlin, including all libraries or SDKs, then your app already supports 16 KB devices. Nevertheless, we recommend that you test your app in a 16 KB environment to verify that there are no unexpected regressions in app behavior.

แอปของคุณใช้โค้ดแบบเนทีฟไหม

แอปของคุณใช้โค้ดเนทีฟหากเป็นไปตามเงื่อนไขข้อใดข้อหนึ่งต่อไปนี้

  • แอปของคุณใช้โค้ด C/C++ (เนทีฟ) หากแอปของคุณใช้คอมโพเนนต์ Android NDK จากนั้นแอปของคุณจะใช้โค้ดแบบเนทีฟ
  • แอปของคุณลิงก์กับไลบรารีเนทีฟหรือทรัพยากร Dependency ของบุคคลที่สามที่ ให้ใช้
  • แอปของคุณสร้างโดยเครื่องมือสร้างแอปของบุคคลที่สามที่ใช้ไลบรารีเนทีฟใน อุปกรณ์

ระบุไลบรารีแบบเนทีฟโดยใช้ตัววิเคราะห์ APK

ตัววิเคราะห์ APK คือเครื่องมือที่ช่วยให้คุณสามารถประเมินแง่มุมต่างๆ ของ APK ทําตามขั้นตอนต่อไปนี้เพื่อระบุว่าแอปใช้โค้ดหรือไลบรารีแบบเนทีฟหรือไม่ ขั้นตอน:

  1. เปิด Android Studio แล้วคลิกไฟล์ > เปิดและเลือกโปรเจ็กต์ใดก็ได้

  2. จากแถบเมนู ให้คลิกสร้าง > วิเคราะห์ APK...

    ตัวเลือกเมนู Studio Build เพื่อเปิด APK เครื่องมือวิเคราะห์

  3. เลือก APK ที่คุณต้องการวิเคราะห์

  4. ดูในโฟลเดอร์ lib ซึ่งโฮสต์ไฟล์ออบเจ็กต์ที่แชร์ (.so) หากมี อยู่ หากมีไฟล์ออบเจ็กต์ที่แชร์อยู่ แสดงว่าแอปของคุณใช้เนทีฟ โค้ด หากไม่มีไฟล์ออบเจ็กต์ที่แชร์ หรือไม่มีโฟลเดอร์ lib แอปของคุณก็ไม่ได้ใช้โค้ดแบบเนทีฟ

    มุมมองตัววิเคราะห์ APK ที่แสดงไฟล์ออบเจ็กต์ที่แชร์ ปัจจุบัน

สร้างแอปที่รองรับอุปกรณ์ขนาด 16 KB

หากต้องการรองรับอุปกรณ์ขนาด 16 KB แอปที่ใช้โค้ดเนทีฟควรดำเนินการตาม ขั้นตอนที่อธิบายในส่วนต่อไปนี้

อัปเดตแพ็กเกจของคลังภาพที่แชร์

เราขอแนะนำให้อัปเกรดเป็น AGP เวอร์ชัน 8.3 ขึ้นไปและใช้ตัวเลือกที่ไม่มีการบีบอัด ไลบรารีที่ใช้ร่วมกัน

AGP เวอร์ชัน 8.3 ขึ้นไป

อุปกรณ์ขนาด 16 KB ต้องใช้แอปที่จัดส่งพร้อมกับไลบรารีที่ใช้ร่วมกันที่ไม่ได้บีบอัด ให้ปรับแนวให้พอดีกับขอบเขตซิปขนาด 16 KB ต้องอัปเกรดก่อน เข้ากับ Android Gradle Plugin (AGP) เวอร์ชัน 8.3 ขึ้นไป โปรดดู Android ส่วนผู้ช่วยการอัปเกรดปลั๊กอิน Gradle สำหรับรายละเอียดเกี่ยวกับกระบวนการอัปเกรด

AGP เวอร์ชัน 8.2 หรือเก่ากว่า

หากคุณไม่สามารถอัปเกรด AGP เป็นเวอร์ชัน 8.3 ขึ้นไป ทางเลือกหนึ่งคือ เปลี่ยนไปใช้ไลบรารีที่ใช้ร่วมกันที่บีบอัด อัปเดตการกำหนดค่า Gradle เป็น ให้ Gradle บีบอัดไลบรารีที่แชร์ของคุณขณะทำแพ็กเกจแอปเพื่อหลีกเลี่ยงแอป ปัญหาการติดตั้งกับไลบรารีที่ใช้ร่วมกันที่ไม่ตรงแนว

ดึงดูด

เพิ่มตัวเลือกต่อไปนี้ในไฟล์ build.gradle

android {
  ...
  packagingOptions {
      jniLibs {
        useLegacyPackaging true
      }
  }
}

Kotlin

เพิ่มตัวเลือกต่อไปนี้ในไฟล์ build.gradle.kts

android {
  ...
  packagingOptions {
      jniLibs {
        useLegacyPackaging = true
      }
  }
}

คอมไพล์แอปโดยใช้การปรับ ELF ขนาด 16 KB

อุปกรณ์ 16 KB ต้องใช้ไลบรารีที่ใช้ร่วมกัน เซกเมนต์ ELF ที่จะจัดแนว ใช้การปรับ ELF ขนาด 16 KB อย่างเหมาะสมเพื่อให้แอปทำงานได้

หากต้องการคอมไพล์แอปโดยใช้การปรับ ELF ขนาด 16 KB ให้ทำตามขั้นตอนใน ส่วนต่อไปนี้ขึ้นอยู่กับเวอร์ชันของ Android NDK ที่คุณใช้ ด้วย

Android NDK r26 และต่ำกว่า

เพื่อรองรับการคอมไพล์ไลบรารีที่ใช้ร่วมกันขนาด 16 KB ด้วย Android NDK เวอร์ชัน r26 หรือต่ำกว่า คุณต้องอัปเดต ndk-build หรือ cmake ดังนี้

Ndk-build

อัปเดต Android.mk เพื่อเปิดใช้การปรับ ELF ขนาด 16 KB ดังนี้

LOCAL_LDFLAGS += "-Wl,-z,max-page-size=16384"

ผู้ผลิต

อัปเดต CMakeLists.txt เพื่อเปิดใช้การปรับ ELF ขนาด 16 KB ดังนี้

target_link_options(${CMAKE_PROJECT_NAME} PRIVATE "-Wl,-z,max-page-size=16384")

Android NDK r27 ขึ้นไป

เพื่อรองรับการคอมไพล์ไลบรารีที่ใช้ร่วมกันขนาด 16 KB ด้วย Android NDK เวอร์ชัน r27 ขึ้นไป คุณต้องอัปเดต ndk-build, build.gradle build.gradle.kts หรือ Linker ที่พบดังต่อไปนี้

Ndk-Build

ใน Application.mk:

APP_SUPPORT_FLEXIBLE_PAGE_SIZES := true

ดึงดูด

ในไฟล์ build.gradle ให้ตั้งค่าอาร์กิวเมนต์ -DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON:

android {
  ...
  defaultConfig {
    ...
    // This block is different from the one you use to link Gradle
    // to your CMake or ndk-build script.
    externalNativeBuild {
      // For ndk-build, instead use the ndkBuild block.
      cmake {
        // Passes optional arguments to CMake.
        arguments "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
      }
    }
  }
}

Kotlin

ในไฟล์ build.gradle.kts ให้ตั้งค่าอาร์กิวเมนต์ -DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON:

android {
  ...
  defaultConfig {
    ...
    // This block is different from the one you use to link Gradle
    // to your CMake or ndk-build script.
    externalNativeBuild {
      // For ndk-build, instead use the ndkBuild block.
      cmake {
        // Passes optional arguments to CMake.
        arguments += listOf("-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON")
      }
    }
  }
}

ระบบบิลด์อื่นๆ

ระบุแฟล็ก Linker ต่อไปนี้

-Wl,-z,max-page-size=16384

ตรวจสอบอินสแตนซ์โค้ดที่อ้างอิงขนาดหน้าเว็บที่เฉพาะเจาะจง

แม้ว่าแอปจะมีขนาด 16 KB แต่แอปก็อาจพบข้อผิดพลาดได้ถ้า ในโค้ดของคุณจะถือว่าอุปกรณ์ใช้ขนาดหน้าที่เจาะจง เพื่อหลีกเลี่ยงปัญหานี้ ทำตามขั้นตอนต่อไปนี้

  1. นำทรัพยากร Dependency แบบฮาร์ดโค้ดที่อ้างอิง PAGE_SIZE ออก คงที่หรืออินสแตนซ์ในตรรกะโค้ดของคุณที่สันนิษฐานว่าหน้าเว็บของอุปกรณ์ ขนาด 4 KB (4096)

    โปรดใช้ getpagesize() หรือ sysconf(_SC_PAGESIZE) แทน

  2. มองหาการใช้งาน mmap() และ API อื่นๆ ที่ต้องมีการปรับแนวหน้าให้ตรงกัน อาร์กิวเมนต์และแทนที่ด้วยทางเลือกอื่นตามความจำเป็น

ในบางกรณี หากแอปของคุณใช้ PAGE_SIZE เป็นค่าที่ใช้สะดวกซึ่งไม่ สัมพันธ์กับขนาดหน้าที่สำคัญ ก็จะไม่ทำให้แอปขัดข้อง เมื่อใช้ในโหมด 16 KB อย่างไรก็ตาม หากมีการส่งค่านี้ไปยังเคอร์เนล ด้วย mmap ที่ไม่มี MAP_FIXED เคอร์เนลจะยังคงใช้ทั้งหน้า ซึ่ง ทำให้สูญเสียความทรงจำไป ด้วยเหตุนี้ ระบบจึงระบุ PAGE_SIZE เมื่อ 16 KB เปิดโหมด NDK r27 ขึ้นไป

หากแอปใช้ PAGE_SIZE ในลักษณะนี้และไม่เคยส่งค่านี้โดยตรงไปยัง เคอร์เนล แทนที่จะใช้ PAGE_SIZE ให้สร้างตัวแปรใหม่ด้วยตัวแปร เพื่อแสดงว่ามีการใช้เพื่อวัตถุประสงค์อื่น และไม่แสดงถึง หน้าความทรงจำ

ทดสอบแอปในสภาพแวดล้อม 16 KB

หลังจากที่สร้างแอปที่รองรับอุปกรณ์ขนาด 16 KB คุณจะต้องทำดังนี้ ทดสอบแอปในสภาพแวดล้อม 16 KB เพื่อดูว่าแอป ปัญหาการถดถอย โดยคุณต้องทำตามขั้นตอนต่อไปนี้:

  1. ตั้งค่า SDK ของ Android 15

  2. ตั้งค่าสภาพแวดล้อมการทดสอบแบบใดแบบหนึ่งต่อไปนี้

  3. เริ่มต้นอุปกรณ์ทดสอบ แล้วเรียกใช้คำสั่งต่อไปนี้เพื่อยืนยันว่า ใช้สภาพแวดล้อมขนาด 16 KB ดังนี้

    adb shell getconf PAGE_SIZE

    คำสั่งควรคืนค่าเป็น 16384

  4. สำหรับไลบรารีที่ใช้ร่วมกัน ให้ยืนยันว่าไลบรารีที่ใช้ร่วมกันของ เซกเมนต์ของ ELF มีการปรับแนวอย่างถูกต้องโดยใช้การจัดแนว ELF ขนาด 16 KB คุณสามารถใช้สคริปต์นี้เพื่อ ความช่วยเหลือเกี่ยวกับขั้นตอนนี้

    #!/bin/bash

# usage: alignment.sh path to search for *.so files

dir="$1"

RED="\e[31m"
GREEN="\e[32m"
ENDCOLOR="\e[0m"

matches="$(find $dir -name "*.so" -type f)"
IFS=$'\n'
for match in $matches; do
  res="$(objdump -p ${match} | grep LOAD | awk '{ print $NF }' | head -1)"
  if [[ $res =~ "2**14" ]] || [[ $res =~ "2**16" ]]; then
    echo -e "${match}: ${GREEN}ALIGNED${ENDCOLOR} ($res)"
  else
    echo -e "${match}: ${RED}UNALIGNED${ENDCOLOR} ($res)"
  fi
done

    1. บันทึกสคริปต์ลงในไฟล์ เช่น alignment.sh

    2. แยกไฟล์ APK ของแอปโดยทำดังนี้

      unzip APK_NAME.apk -d /tmp/my_apk_out

    3. เรียกใช้สคริปต์กับไฟล์ที่แยกออกมาใน /tmp/my_apk_out ไดเรกทอรี:

      alignment.sh /tmp/my_apk_out | grep "arm64-v8a"

      สคริปต์จะแสดงผลเป็น ALIGNED หรือ UNALIGNED สำหรับ คลังภาพที่แชร์ arm64-v8a รายการ

    4. หากไลบรารีที่ใช้ร่วมกันของ arm64-v8a เป็น UNALIGNED คุณจะต้อง ให้อัปเดตแพ็กเกจสำหรับไลบรารีเหล่านั้น แล้วคอมไพล์อีกครั้ง และทดสอบอีกครั้งโดยทำตามขั้นตอนในส่วนนี้

  5. เรียกใช้คำสั่ง zipalign ต่อไปนี้เพื่อยืนยันว่าแอปของคุณ 16 KB โดยที่ APK_NAME เป็นชื่อของ ไฟล์ APK ของแอปคุณ

    zipalign -c -P 16 -v 4 APK_NAME.apk

  6. ทดสอบแอปอย่างละเอียด โดยมุ่งเน้นส่วนที่อาจได้รับผลกระทบจาก การเปลี่ยนอินสแตนซ์โค้ดที่อ้างอิงขนาดหน้าเว็บที่เจาะจง

ตั้งค่า Android Emulator ด้วยอิมเมจระบบ Android 15 ขนาด 16 KB

หากต้องการตั้งค่าสภาพแวดล้อมขนาด 16 KB โดยใช้ Android Emulator โปรดทำตามขั้นตอนต่อไปนี้ ขั้นตอน:

  1. อิมเมจระบบจำลอง Android 15 ขนาด 16 KB สามารถใช้งานร่วมกับ Android Studio Jellyfish | 2023.3.1 ขึ้นไป แต่สำหรับสิ่งที่ดีที่สุด เมื่อใช้งาน Android 15 รุ่นเบต้า ให้ดาวน์โหลดเวอร์ชันล่าสุด เวอร์ชันตัวอย่างของ Android Studio

    โปรดทราบว่าคุณใช้ Android Studio เวอร์ชันที่มีอยู่ต่อไปได้ ติดตั้งแล้ว เนื่องจากคุณติดตั้งหลายเวอร์ชันควบคู่กันไปได้

  2. ใน Android Studio ให้คลิกเครื่องมือ > SDK Manager

  3. ในแท็บแพลตฟอร์ม SDK ให้เลือกแสดงรายละเอียดแพ็กเกจ แล้วขยาย ส่วนตัวอย่าง Android VanillaIceCream แล้วเลือก อิมเมจระบบจำลองต่อไปนี้ ขึ้นอยู่กับอุปกรณ์เสมือนที่คุณใช้ ต้องการสร้าง:

    • รูปภาพระบบขนาด 16k ของ Google APIs รุ่นทดลอง ARM 64 v8a
    • Google APIs ขนาด 16k เวอร์ชันทดลองของ Intel x86_64 อิมเมจระบบ Atom

    ดาวน์โหลดอิมเมจระบบโปรแกรมจำลอง 16 KB โดยใช้ SDK Manager ใน Android สตูดิโอ

  4. คลิกใช้ > ตกลง เพื่อดาวน์โหลดอิมเมจระบบที่คุณเลือก

  5. ทำตามขั้นตอนเพื่อตั้งค่าอุปกรณ์เสมือนสำหรับ Android 15 และเมื่อ แจ้งให้เลือกรูปภาพระบบ เลือกอิมเมจระบบขนาด 16 KB ที่คุณดาวน์โหลด หากระบบไม่แนะนําโดยอัตโนมัติ คุณสามารถดู รูปภาพระบบขนาด 16 KB ในแท็บรูปภาพอื่นๆ

    ค้นหารูปภาพโปรแกรมจำลอง 16 KB ในรูปภาพอื่นๆ แท็บ

ก่อนหน้า
การรองรับ 64 บิต