앱 메모리 예산 설정

앱 메모리 예산을 사용하면 앱에서 상주하는 메모리 양에 소프트 한도를 설정할 수 있습니다. 앱이 예산을 초과해도 시스템은 앱을 종료하지 않습니다. 대신 앱이 최근에 사용하지 않은 메모리를 회수하므로 앱은 작업 세트(사용자가 수행하는 작업에 적극적으로 필요한 메모리)를 유지하고 나머지를 기기에 반환합니다.

예산은 앱의 작업 집합을 알고 있고 시스템 및 번들 앱 또는 메모리가 제한된 기기를 타겟팅하는 앱과 같이 메모리 사용량을 확인하려는 경우에 가장 유용합니다.

이 페이지에서는 다음 주제에 대해 설명합니다.

메모리 예산 작동 방식

메모리 제거 및 스왑을 사용하여 최근에 사용되지 않은 메모리 페이지를 삭제하고 앱의 메모리 사용량을 현재 작업 세트에 집중함으로써 예산의 균형을 유지합니다. 앱이 선언된 예산을 초과하면 운영체제는 해당 앱을 구체적으로 타겟팅하여 회수합니다.

  1. 클린 파일 지원 페이지(예: 비활성 코드 및 매핑된 애셋)는 필요할 때 저장소에서 다시 읽을 수 있으므로 먼저 제거됩니다.
  2. 더티 파일 지원 페이지는 저장소에 다시 기록되고 제거됩니다.
  3. 익명 메모리 페이지(예: 힙 할당)는 압축되어 zRAM으로 스왑됩니다.

회수는 새로운 할당을 위한 공간을 확보하고 앱의 메모리 사용량을 예산 내로 유지합니다.

특정 시점에 앱에 필요한 것(작업 세트)과 설정된 예산 사이에 여유가 있는 한 앱은 계속 정상적으로 실행됩니다. 앱이 작업 세트보다 작은 예산을 설정하면 런타임 시 앱 성능이 저하될 수 있습니다.

OS가 메모리를 추적하고 회수하는 방법을 알아보려면 메모리 아키텍처 가이드를 참고하세요.

Android 매니페스트에서 예산 선언

AndroidManifest.xml를 사용하여 정상 사용 중에 앱이 작동하는 기준 예산인 정상 상태 메모리 예산을 선언합니다. 매니페스트 선언에는 런타임 코드가 필요하지 않으며 프로세스 시작 시 적용되고 foreground, perceptible, background 상태 간에 예산을 전환합니다. PackageManager.getMemoryBudgets는 정적 <application> 예산 선언을 노출합니다. 매니페스트에 커밋하기 전에 예산을 테스트하고 원격 롤백으로 출시하려면 예산 보정, 테스트, 출시를 참고하세요.

<memory-budget> 선언은 Android 17 QPR2(API 수준 37.2) 이상을 실행하는 기기에서 적용됩니다. 하위 Android 버전에서는 플랫폼 매니페스트 파서가 인식되지 않는 XML 요소를 무시하므로 이전 버전과의 호환성에 영향을 주지 않고 <memory-budget>를 채택할 수 있습니다.

빌드 구성

앱 메모리 예산을 채택하기 위해 minSdk 또는 targetSdk를 높일 필요는 없습니다. <processes> 내에서 프로세스별 예산을 선언하려면 Android Gradle 플러그인 9.5.0 이상이 필요합니다. <memory-budget> 매니페스트 속성, MemoryBudgetManager, Build.VERSION_CODES_FULL.CINNAMON_BUN_2를 컴파일하려면 모듈의 build.gradle.kts 또는 build.gradle 파일에서 minorApiLevel = 2를 사용하여 compileSdk를 API 수준 37로 설정합니다.

Kotlin

android {
    compileSdk {
        version = release(37) {
            minorApiLevel = 2
        }
    }
}

Groovy

android {
    compileSdk {
        version = release(37) {
            it.minorApiLevel = 2
        }
    }
}

기준 예산 선언

대부분의 앱에서는 애플리케이션에 단일 예산을 정의하는 것만으로 충분합니다. <application> 태그 내에 직접 <memory-budget> 요소를 선언합니다.

<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>

이렇게 하면 패키지의 모든 프로세스와 상태에 256MB 상주 메모리 예산이 설정됩니다. 앱의 메모리 사용량이 256MB를 초과하면 운영체제는 제거 및 스왑을 사용하여 비활성 메모리 페이지를 자릅니다.

프로세스 상태에 따라 예산 변경

앱은 사용자 공개 상태에 따라 다양한 양의 메모리가 필요합니다.

  • 포그라운드: 프로세스가 사용자와 상호작용하는 표시되는 Activity를 호스팅합니다. 이 상태는 일반적으로 활성 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 최고점)가 아닌 해당 상태의 활성 작업 집합을 타겟팅합니다.

  • 원활한 프레임 렌더링을 위한 foreground 예산 크기 조정: 포그라운드 UI에 활성 작업 세트를 위한 충분한 여유 공간을 제공하여 동기식 회수가 프레임 렌더링을 지연시키지 않도록 합니다. 앱에 메모리 집약적인 독립형 워크플로(예: 고해상도 이미지 또는 동영상 편집기)가 포함된 경우 해당 활동을 전용 프로세스로 이동하여(다중 프로세스 앱 참고) 할당이 독립적으로 예산에 반영되고 사용자가 종료할 때 해제되도록 하는 것이 좋습니다.
  • 헤드리스 작업에 background 예산을 엄격하게 설정: 필드 원격 분석의 높은 백그라운드 RSS는 포그라운드를 벗어난 후 유지되는 UI 할당(메모리 집약적 UI와 바인딩된 서비스 공동 배치 및 이벤트에 응답하여 메모리 해제 참고) 또는 백그라운드 색인 생성 및 동기화 중 일회성 파일 읽기를 반영하는 경우가 많습니다. 헤드리스 백그라운드 작업에는 프레임 기한이 없으므로 백그라운드 동기화가 예산을 초과하여 일시적으로 할당할 때 일회성 파일 캐시 페이지를 제거하고 비활성 힙 페이지를 zRAM으로 스왑하면 사용자에게 표시되는 버벅거림이 발생하지 않으며 백그라운드 급증으로 인해 사용자의 포그라운드 앱이 제거되는 것을 방지할 수 있습니다.

단계별 워크플로는 예산 보정을 참고하세요.

예산 상태가 프로세스 상태에 매핑되는 방식

플랫폼은 RunningAppProcessInfo.importance에 따라 매니페스트 예산 상태를 런타임 프로세스 상태에 매핑합니다. 이는 활동 관리자가 프로세스 자체의 활성 구성요소와 다른 앱에서 들어오는 서비스 바인딩 또는 콘텐츠 제공자 쿼리 모두에서 계산합니다.

  • foreground: 활성 상태의 표시되는 사용자 상호작용입니다. 예를 들어 재개된 Activity 호스팅, 화면이 꺼질 때 최상위 앱 상태 유지, 최상위 포그라운드 앱에 의해 활성 상태로 바인딩되거나 쿼리되는 서비스 또는 콘텐츠 제공자 호스팅이 있습니다.
  • perceptible: 활성 미디어 재생, 세부 경로 안내 내비게이션, 카메라 또는 마이크 캡처, 활성 백그라운드 다운로드, 데이터 동기화 포그라운드 서비스 또는 BIND_NOT_FOREGROUND과 같은 플래그를 사용하여 포그라운드 클라이언트에 의해 바인딩된 서비스와 같이 표시되는 창 없이 사용자가 인식할 수 있는 워크로드입니다(BIND 플래그로 상속 제어 참고). 내부 플랫폼 측정항목은 이러한 워크로드 중 일부를 PROCESS_STATE_IMPORTANT_FOREGROUND로 라벨을 지정할 수 있지만, 이 내부 상수는 표시되는 기간을 나타내지 않으며 perceptible 예산에 의해 제어됩니다.
  • background: 백그라운드 작업, 알람, broadcast receiver와 같이 사용자에게 즉시 인식되지 않는 작업입니다.

다음 표에서는 런타임 중요도 수준이 매니페스트 상태에 매핑되는 방식을 보여줍니다.

매니페스트 android:state 런타임 중요도(RunningAppProcessInfo) 일반적인 구성요소
foreground IMPORTANCE_FOREGROUND
IMPORTANCE_TOP_SLEEPING
재개된 표시 활동, 화면이 잠긴 상단 앱, 상단 앱에 의해 바인딩된 서비스 또는 콘텐츠 제공업체
perceptible IMPORTANCE_FOREGROUND_SERVICE
IMPORTANCE_VISIBLE
활성 미디어 재생, 탐색, 다운로드 또는 동기화 포그라운드 서비스, 포그라운드 서비스 또는 표시 플래그와 결합된 서비스
background IMPORTANCE_PERCEPTIBLE
IMPORTANCE_CANT_SAVE_STATE
IMPORTANCE_SERVICE
IMPORTANCE_CACHED
백그라운드 작업, 수신기, 백그라운드 동기화, 캐시된 프로세스

클라이언트 바인딩이 서비스 또는 프로바이더 호스트 프로세스를 승격하는 방법과 클라이언트가 바인딩을 해제하거나 화면 밖으로 이동한 후 프로세스가 background 또는 cached로 다시 전환되는 방법에 관한 자세한 내용은 서비스 결합 및 프로세스 상태를 참고하세요.

프로세스가 활성 구성요소가 없는 캐시된 상태(IMPORTANCE_CACHED)로 전환되면 플랫폼은 캐시된 프로세스 고정 및 회수와 함께 background 메모리 예산을 계속 적용하여 고정이나 압축이 발생하지 않더라도 프로세스를 제한된 상태로 유지합니다.

앱의 프로세스 상태 및 예산 검사

개발 중에 앱의 활성 프로세스 상태와 중요도를 검사하는 한 가지 방법은 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>

멀티 프로세스 앱

애플리케이션이 여러 프로세스에 걸쳐 작업을 분할하는 경우 <processes> 내의 <process> 태그를 사용하여 전용 프로세스 예산을 구성합니다.

예를 들어 스트리밍 음악 앱(com.example.radio)을 생각해 보세요.

  1. 기본 프로세스: 표시되는 UI와 오디오 재생 엔진(mediaPlayback 포그라운드 서비스가 있는 MediaSessionService)을 호스팅합니다. 표시되면 프로세스는 180MB 포그라운드 예산에서 작동합니다. 음악이 계속 재생되는 동안 사용자가 앱을 종료하면 프로세스가 perceptible 상태로 전환되며, 이 상태에서는 재생 엔진과 오디오 버퍼에 64MB 예산이면 충분합니다.
  2. 동기화 프로세스(: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> 블록을 선언할 때 <memory-budget>를 선언하는 프로세스의 <process> 항목만 나열합니다. 특정 하위 프로세스만 예산을 책정하고 나머지 앱은 기기의 시스템 한도로 유지하려면 <application> 바로 아래에 있는 <memory-budget> 요소를 생략하면 됩니다.

하위 프로세스의 메모리 사용량은 프로세스 예산과 둘러싸는 패키지 예산 모두에 반영됩니다. 프로세스는 런타임에 프로세스 예산 또는 패키지 예산 중 먼저 도달하는 기준점을 위반하는 경우 메모리 부족을 경험합니다.

고밀도 디스플레이의 예산 확장

한 번에 그려야 하는 픽셀 수에 따라 메모리 사용량이 크게 확장되는 앱(예: 창 크기에 맞게 비트맵을 캐싱하는 사진 갤러리 앱)의 경우 Android는 디스플레이 사양에 따라 예산을 동적으로 확장하는 두 가지 대체 메커니즘을 제공합니다.

  • 디스플레이 밀도 버킷별 확장(android:additionalMbPerDensity): 2D 래스터 드로어블 및 UI 애셋이 너비와 높이 모두에서 확장되므로 mdpi(1.0x/160dpi)를 기준으로 디스플레이 밀도 비율의 제곱에 비례하여 메가바이트를 추가합니다.

    <!-- Baseline 180MB + 16MB multiplied by (density ratio)^2 -->
    <memory-budget
        android:maxMb="180"
        android:additionalMbPerDensity="16" />
    

    mdpi 디스플레이(1.0x)에서 예산은 180 + 16 × 12 = 196MB입니다. xxhdpi 디스플레이(3.0x)에서 예산은 180 + 16 × 32 = 324MB로 확장됩니다.

  • 창 픽셀 수로 확장(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 &approx; 259만 픽셀)에서 이는 기준 예산에 41,472,000바이트(&approx; 39.6MB, 여기서 1MB = 1,048,576바이트)를 추가합니다. 1440p 창(1440 × 3120 &approx; 4.49M 픽셀)에서는 71,884,800바이트(&approx; 68.6MB)가 추가됩니다.

이 두 속성은 대체 속성입니다. 앱의 기본 배율과 일치하는 속성을 선택하고 동일한 절에서 두 속성을 결합하지 마세요.

기기 폼 팩터에 맞게 전문화

휴대전화, 태블릿, Wear OS에 APK를 배포할 때 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> 요소를 정의하는 경우 시스템은 매니페스트에 표시되는 순서대로 요소를 평가하고 마지막으로 적용 가능한 예산 절을 적용합니다.

생략된 android:state는 기본적으로 foreground로 설정되며, 이후 절에서 이러한 상태를 재정의하지 않는 한 perceptible 및 background에도 적용됩니다. foreground(또는 생략된 android:state)에서 perceptible, background로 절을 정렬하고 일치하는 상태 그룹 내에 android:feature 재정의를 배치하여 후행 생략 상태 재정의가 이전 perceptible 또는 background 절을 가리지 않도록 합니다.

XML 속성 참조

모든 메가바이트(MB) 속성은 바이너리 단위(1MB = 1,048,576바이트)를 사용하며 Linux cgroup memory.current 요금(Zygote의 공유 메모리 제외)에 매핑됩니다.

속성 형식 기본값 설명
android:maxMb 정수(> 0) 필수 기준 상주 메모리 예산 한도(MB)입니다.
android:state Enum foreground 이 예산이 적용되는 프로세스 상태: foreground, perceptible 또는 background 생략하면 기본값은 foreground이고 이후 절에서 재정의되지 않는 한 perceptible 및 background로 연쇄 적용됩니다.
android:additionalMbPerDensity 정수(0 이상) 0 mdpi(1.0x)에 대한 디스플레이 밀도 비율의 제곱을 곱한 추가 메가바이트입니다.
android:additionalBytesPerDisplayPixel 정수(0 이상) 0 창 픽셀당 할당된 추가 바이트(WindowMetrics.getBounds 너비 × 높이)로, 표면 버퍼 및 비트맵에 유용합니다.
android:feature 문자열 모두 특정 하드웨어 기능(watch, automotive 또는 leanback)을 선언하는 기기로 절을 제한합니다.

런타임 API

Android는 선언적 <memory-budget> 매니페스트 절과 함께 다음 작업을 위한 런타임 SDK API를 제공합니다.

  • 단계별 예산 출시에 설명된 대로 원격 구성 뒤에 있는 후보 예산을 AndroidManifest.xml에 커밋하기 전에 검증합니다.
  • 프로세스 내에서 실시간 cgroup 메모리 사용량과 유효 예산을 쿼리합니다.
  • 가벼운 작업 중에 프로세스 또는 패키지 예산을 동적으로 줄입니다.
  • 운영체제가 메모리를 회수할 때 캐시를 자르기 위해 예산 초과 이벤트를 수신 대기합니다.

Android SDK API (MemoryBudgetManager)

MemoryBudgetManager 시스템 서비스는 Android 17 QPR2(부 SDK 출시, API 수준 37.2/Build.VERSION_CODES_FULL.CINNAMON_BUN_2)부터 Kotlin 및 Java로 작성된 앱에서 사용할 수 있습니다.

서비스 가져오기

MemoryBudgetManager에 액세스하기 전에 SDK_INT_FULL를 확인하여 기기에서 Android 17 QPR2 이상을 실행하는지 확인합니다. 앱의 minSdk가 36보다 작으면 먼저 SDK_INT를 확인하여 Android 15(API 수준 35) 이하를 실행하는 기기에서 SDK_INT_FULL를 읽을 때 NoSuchFieldError가 발생하지 않도록 합니다.

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()

foreground, perceptible, background 상태에 대해 별도의 한도를 지정하는 <memory-budget> 매니페스트 절과 달리 MemoryBudgetManager를 통해 설정된 동적 예산은 코드가 업데이트되거나 삭제될 때까지 단일 런타임 상한을 적용합니다. 런타임 API를 사용하여 필드 실험을 실행하거나 상태별 한도를 관리하는 경우 적응형 이미지 편집기 예와 같이 ProcessLifecycleOwner 또는 활동 수명 주기 콜백을 통해 수명 주기 전환 전반에서 동적 예산을 업데이트하거나 지웁니다.

성능 및 멱등성

런타임에 MemoryBudgetManager를 사용할 때는 다음 특성에 유의하세요.

  • 멱등성: 모든 예산 변형 API는 멱등적입니다. clearProcessBudget() 또는 clearPackageBudget()를 반복적으로 호출하거나 활성 상태인 동적 예산이 없을 때 호출하는 것은 안전한 노옵스(no-ops)입니다. 마찬가지로 setProcessBudgetBytes() 또는 setPackageBudgetBytes()를 동일한 값으로 연속해서 설정해도 중복 시스템 재구성이 트리거되지 않습니다.
  • 호출 빈도: 예산을 설정, 업데이트 또는 삭제하면 시스템 서비스에 대한 교차 프로세스 호출이 이루어져 프로세스의 운영체제 메모리 컨트롤러가 업데이트됩니다. 가볍지만 완전히 무료는 아닙니다. 개별 수명 주기 전환 및 작업 마일스톤(예: 활동 시작 또는 종료, 백그라운드 프로세스 시작 또는 완료, 음성 요청 처리) 중에 이러한 API를 호출하고, 타이트 루프, 오디오 처리 스레드 또는 프레임별 렌더링 루틴에서 호출하지 마세요.
  • 쿼리 빈도: 쿼리 속성 processCurrentUsageBytes, packageCurrentUsageBytes, processBudgetBytes, packageBudgetBytes는 시스템 서비스를 호출하는 대신 로컬 네이티브 호출을 통해 프로세스 내에서 실시간 cgroup 한도 및 사용량을 읽습니다. 이러한 쿼리는 빠르지만 타이트 루프에서 폴링하는 대신 필요에 따라(예: 작업 전환 중 또는 OnOverBudgetListener 콜백 내에서) 호출하세요.

예산 초과 압박 콜백 수신 대기

앱은 메모리 사용량이 예산 기준점을 초과할 때 알림을 받도록 리스너를 등록할 수 있습니다. 이렇게 하면 운영체제가 메모리를 회수하여 프로세스 또는 패키지를 예산 내로 유지하는 동안 앱이 사전 예방적 앱 수준 정리(예: 메모리 내 비트맵 캐시 지우기)를 실행할 수 있습니다.

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: 가능하면 배경 HandlerThread Looper을 registerProcessOverBudgetListener 또는 registerPackageOverBudgetListener에 전달합니다. 백그라운드 스레드에서 캐시 제거 또는 파일 삭제를 실행하면 프로세스가 메모리 압박을 받는 동안 UI 스레드에서 프레임 렌더링과 경합하는 것을 방지할 수 있습니다. 기본 스레드 바인딩 UI 상태만 터치하는 리스너를 위해 Looper.getMainLooper를 예약합니다.
  • 반복 콜백 예상: 예산 초과 콜백은 일회성 알림이 아닙니다. 사용량이 예산을 초과하면 운영체제는 먼저 콜드 페이지를 회수하고, 압박이 계속되면 시스템은 메모리를 계속 회수하고 리스너를 최대 1초에 한 번 호출합니다. 콜백을 멱등성으로 만듭니다. 앱에 단일 알림만 필요하거나 정리 패스 간에 더 긴 대기 시간이 필요한 경우 콜백 내에서 unregisterProcessOverBudgetListener(또는 unregisterPackageOverBudgetListener)를 호출하거나 대기 시간 타임스탬프 또는 AtomicBoolean를 사용하여 정리를 보호합니다.
  • 예산을 줄이기 전에 등록: setProcessBudgetBytes 또는 setPackageBudgetBytes를 호출할 때 현재 메모리 사용량이 이미 새 예산을 초과하는 경우 새 예산이 적용되는 즉시 예산 초과 이벤트가 트리거됩니다. 앱에서 초기 예산 초과 알림을 놓치지 않도록 예산을 설정하기 전에 리스너를 등록하세요.
  • 신속성: 복구 작업은 즉각적인 해결책을 제공해야 합니다. 압박을 받는 동안 복잡한 계산을 수행하면 성능이 저하됩니다.
  • 할당 방지: 콜백 내에서 새 객체를 할당하거나 새 스레드를 시작하지 마세요. 이렇게 하면 즉각적인 운영체제 직접 회수가 트리거될 수 있습니다.
  • 수익률이 높은 타겟에 집중: 큰 비트맵, 렌더링 버퍼를 제거하거나 메모리 매핑 파일을 닫는 것이 작은 객체를 많이 해제하는 것보다 훨씬 효과적입니다.

Runtime API 예시

다음 예는 Kotlin에서 Android SDK API를 사용하여 런타임 API를 구현하는 방법을 보여줍니다.

Android SDK 예: 적응형 이미지 편집기

이 예에서는 매니페스트가 다중 레이어 캔버스를 수용하기 위해 256MB 상한을 선언하는 이미지 편집 앱(com.example.imageeditor)을 보여줍니다.

<manifest ... >
    <application ... >
        <!-- Manifest ceiling accommodates the heaviest editing workload -->
        <memory-budget android:maxMb="256" />
    </application>
</manifest>

사용자가 가벼운 썸네일 갤러리를 탐색할 때 앱은 Kotlin의 Android SDK API를 사용하여 프로세스 예산을 96MB로 동적으로 줄입니다. 사용자가 다중 레이어 편집 캔버스를 열면 앱은 동적 예산을 지워 전체 256MB 매니페스트 한도를 복원합니다. 또한 백그라운드 HandlerThread Looper에 OnOverBudgetListener를 등록한 후 갤러리 예산을 적용하여 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"
    }
}

예산 보정, 테스트, 출시

메모리 예산을 올바르게 구현하려면 다음 세 단계를 거쳐야 합니다.

  1. 각 프로세스 상태의 예산을 보정합니다.
  2. 출시하기 전에 철저히 테스트하세요.
  3. 단계적으로 출시: 원격 구성 뒤에서 검증하고 매니페스트로 승격한 후 계속 측정합니다.

예산 조정

적절한 예산은 제한되지 않은 최고점이 아니라 특정 상태의 앱 작업 세트 바로 위에 있습니다. 이 지점을 찾으려면 현실적인 사용자 플로우를 실행하고 예산을 단계별로 낮추고 앱이 비용을 지불하기 시작하는 순간을 확인합니다.

작업 세트와 상주 메모리 이해하기

예산이 없으면 앱의 상주 메모리 사용량(memory.current)은 두 가지 유형의 메모리를 보유합니다.

  • 작업 세트: Java, Kotlin, 네이티브 힙, 현재 사용자 플로우가 반복적으로 터치하는 핫 파일 지원 페이지(DEX 코드, 네이티브 라이브러리, 애셋)
  • 콜드 슬랙: 이전 화면의 비트맵 캐시, 일회성 시작 버퍼, 할당 버스트 후 남은 힙 슬랙, 한 번 읽고 다시 터치하지 않은 파일 페이지

제약이 없는 피크 시점의 예산은 콜드 슬랙을 회수하지 않습니다. 작업 세트보다 낮은 예산은 커널이 힙 페이지를 스왑 아웃하고 앱이 즉시 다시 오류를 일으키는 코드 페이지를 제거하게 합니다. 이러한 작업 세트 리폴트는 CPU 시간과 배터리를 소모하며 UI 스레드에 도달하면 프레임도 소모합니다.

찾고 있는 것은 knee입니다. 즉, 회수가 콜드 여유 공간만 삭제하므로 예산이 없어도 재오류, CPU 시간, 프레임 시간이 그대로 유지되는 가장 낮은 예산입니다.

테스트 환경 준비

프로덕션과 유사하게 작동하는 반복 가능한 테스트를 설정합니다.

  • 출시하는 것과 동일한 R8 최적화, 디버그 불가능한 출시 빌드를 보정합니다. 디버그 빌드는 더 많은 메모리를 사용하므로 디버그 빌드에 맞게 조정된 예산은 출시하기에 너무 높습니다.
  • Android 17 QPR2(API 수준 37.2) 이상을 실행하는 기기 또는 에뮬레이터에서 테스트합니다. 셸에서 앱의 cgroup 디렉터리를 읽으려면 adb root가 필요할 수 있으므로 adb shell에서 cgroup 파일을 샘플링할 때는 userdebug 빌드 또는 Google Play가 없는 에뮬레이터 이미지가 편리합니다. 앱은 프로덕션 빌드에서도 MemoryBudgetManager를 통해 자체 프로세스 cgroup 사용량을 프로세스 내에서 읽을 수 있습니다.
  • 예산을 책정하려는 각 상태에 대해 Jetpack Macrobenchmark, UI Automator 또는 adb shell input를 사용하여 30~60초 길이의 사용자 플로우를 한 번 스크립팅합니다. 유휴 앱은 작업 세트에 관해 아무것도 알려주지 않습니다.
    • foreground: 밀도가 높은 목록과 미디어 그리드를 스크롤하고, 기본 대상 간에 이동하고, 메뉴와 대화상자를 열고, 애니메이션을 실행합니다.
    • perceptible: 인지 가능한 작업(예: 오디오 재생 또는 다운로드)이 계속되는 동안 표시되는 창을 종료하고 10~15초 동안 실행한 후 앱으로 돌아갑니다.
    • background: 앱에 표시되는 UI가 없는 동안 동기화, WorkManager 작업(예: adb shell cmd jobscheduler run -f <package-name> <job-id> 사용), 시작된 서비스 또는 broadcast receiver를 트리거합니다.

프로세스가 캐시된 상태(IMPORTANCE_CACHED)에서 유휴 상태일 때가 아니라 백그라운드 작업이 활발하게 실행되는 동안 background 예산을 측정합니다. 캐시된 동안에도 background 예산은 계속 적용되지만 유휴 상태의 캐시된 프로세스는 백그라운드 작업을 실행하지 않으며 백그라운드 작업 또는 수신기의 작업 집합을 반영하지 않습니다.

기준 측정

예산이 전혀 없는 실행부터 시작하여 정상적인 상태가 어떤지 파악합니다. <memory-budget> 선언 없이 빌드를 사용하고 새 프로세스(adb shell am force-stop <package-name>)에서 각 실행을 시작합니다.

각 앱 프로세스에는 자체 cgroup v2 메모리 컨트롤러가 있습니다. 경로를 하드 코딩하는 대신 /proc/<PID>/cgroup의 0:: 줄에서 경로를 조회합니다. 각 기기 명령어를 작은따옴표로 묶은 문자열로 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 스왑으로 압축된 메모리(바이트)
  • memory.stat의 anon 및 file: 상주 익명 및 파일 지원 메모리(바이트)
  • memory.stat의 workingset_refault_anon 및 workingset_refault_file: 앱에 다시 필요한 스왑아웃되거나 제거된 페이지의 실행 횟수입니다. 이러한 카운터는 예산이 너무 빠듯하다는 주요 신호입니다.

adb shell에서 앱의 cgroup 파일을 읽을 때 권한 오류가 발생하면 Google Play 없이 userdebug 빌드 또는 에뮬레이터 이미지에서 adb root를 실행한 후 다시 시도하세요. adb root를 사용할 수 없는 프로덕션 user 빌드에서는 앱 내에서 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> 120MB
adb shell am memory-limiter manual <PID> none

수동 재정의는 프로세스 상태 변경 전반에 걸쳐 해당 프로세스 인스턴스의 전체 기간 동안 지속되므로 계속하기 전에 지우거나 프로세스를 다시 시작하세요. 또한 프로세스의 하드 한도(memory.max)를 동일한 값으로 설정하므로 앱의 작업 세트보다 낮은 후보 예산은 프로세스를 느리게 하는 대신 종료할 수 있습니다. 이는 실패한 예산으로 간주됩니다.

계측 인수에서 후보 값을 읽고 MemoryBudgetManager.processBudgetBytes를 설정하여 벤치마크 빌드에서 스윕할 수도 있습니다. 런타임 예산은 매니페스트 예산만 강화할 수 있으므로 <memory-budget> 선언 없이 빌드를 스윕합니다. 또한 clearProcessBudget를 호출할 때까지 프로세스 상태 변경 전반에 걸쳐 적용됩니다.

기준에서 가장 높은 memory.current에서 시작하여 한 번에 10~15MB씩 줄입니다. 각 후보 예산에 대해 다음을 수행합니다.

  1. 새 프로세스를 시작하고 타겟 상태로 전환한 후 예산을 적용합니다.
  2. 사용자 플로우를 준비 단계로 한 번 실행합니다. 예산을 적용하면 콜드 스타트업 페이지가 한 번 제거되며, 이 전환보다는 안정적인 상태를 측정하려고 합니다.
  3. 프레임 통계를 재설정하고 시작 리폴트 카운터와 프로세스 CPU 시간(utime 및 stime, 클록 틱 단위)을 기록합니다.

    adb shell dumpsys gfxinfo <package-name> reset
    adb shell "grep -E '^workingset_refault_(anon|file) ' $CG/memory.stat"
    adb shell "cut -d ' ' -f 14,15 /proc/$PID/stat"
  4. 사용자 플로우의 측정된 패스를 실행합니다.

  5. memory.current, anon, file, 리폴트 카운터, CPU 시간을 다시 기록하고 프레임 통계를 수집합니다. dumpsys gfxinfo는 동일한 통계를 두 번 이상 출력할 수 있으므로 전체 앱을 포괄하는 첫 번째 일치를 사용합니다.

    adb shell "dumpsys gfxinfo <package-name>" | grep -m 1 'Janky frames:'
    adb shell "dumpsys gfxinfo <package-name>" | grep -m 1 '95th percentile'

각 후보를 최소 3회 반복하고 한 후보의 모든 반복을 연속으로 실행하는 대신 후보를 인터리브 처리합니다. 각 결과를 단일 실행이 아닌 기준 실행의 분포와 비교합니다.

결과 읽기

예산이 줄어들면 앱은 세 가지 상태를 거칩니다.

  • 무릎 위: memory.current는 콜드 file 페이지와 유휴 힙을 삭제하여 예산을 줄입니다. anon는 평탄하게 유지되고, 리폴트는 기준선 근처에 유지되며, CPU 시간과 프레임 시간은 움직이지 않습니다. 이것이 바로 우리가 원하는 것입니다.
  • 무릎 아래: 콜드 페이지가 사라지므로 커널은 앱에서 여전히 사용하는 힙 페이지를 스왑 아웃하기 시작합니다. 실행당 수백 또는 수천 페이지씩 리폴트가 급증하고 CPU 시간이 증가합니다. 프레임 시간은 유휴 테스트 기기에서 거의 움직이지 않을 수 있지만, 이제 앱은 자체 작업 세트를 압축하고 압축 해제하는 데 CPU 시간과 배터리를 사용합니다.
  • 무릎 아래: 회수 및 스왑인 오류가 UI 스레드와 RenderThread에 발생하고 버벅거림, 프레임 시간, 웜 재개 시간이 모두 증가합니다.

제약이 없는 기준과 비교하여 후보 예산이 다음을 모두 충족하는 경우 합리적인 시작점으로 간주됩니다.

  • 실행 중 프로세스가 유지됨
  • 기본값으로 돌아간 델타가 기준선에 가깝게 유지됨
  • 프로세스 CPU 시간이 5% 이하로 증가
  • 버벅거리는 프레임이 1%포인트 이하로 증가
  • P95 프레임 시간이 3ms 이하로 증가
  • perceptible 및 background 예산의 경우 웜 재개 시간(adb shell am start -W의 TotalTime)이 15% 이하로 증가합니다.

무릎은 통과하는 가장 낮은 후보 예산입니다. 예를 들어 다음은 제한되지 않은 최대 메모리가 138MB인 가상의 앱에 대한 포그라운드 스윕입니다.

후보 예산 memory.current anon file 리폴트(페이지) P95 프레임 시간 체제
없음 138MB 75MB 63MB 0 10.5ms 기준
125MB 121MB 74MB 47MB 10 10.5ms 무릎 위
110MB 110MB 75MB 35MB 15 10.8ms 무릎
95MB 95MB 74MB 21MB 176 11.2ms 무릎 아래
85MB 85MB 68MB 17MB 2,050 12.8ms 무릎 아래
70MB 70MB 54MB 16MB 8,771 16.5ms 무릎 아래

예산 선택

사용자 데이터, 언어, 할당 버스트의 차이로 인해 앱이 이 값 아래로 내려가지 않도록 android:maxMb를 니보다 10% ~20% 높게 설정합니다. 앞의 예시에서 무릎은 110MB이므로 125MB가 적합합니다.

그런 다음 새 <memory-budget> 선언이 포함된 출시 빌드를 설치하고 사용자 플로우를 다시 실행한 후 통과 기준이 여전히 유지되는지 확인합니다. 런타임에 활성 예산을 확인하려면 MemoryBudgetManager.processBudgetBytes 또는 MemoryBudgetManager.packageBudgetBytes를 쿼리합니다.

warm return으로 포그라운드가 아닌 예산 검증

앱이 이 상태에 있는 동안에는 perceptible 또는 background 예산이 부족해도 괜찮아 보일 수 있지만 사용자가 돌아오면 비용이 발생합니다. 돌아오는 여정도 테스트합니다.

  1. 포그라운드 흐름을 실행하고 앱을 타겟 상태로 이동한 후 am memory-limiter manual를 사용하여 후보 예산을 적용합니다.
  2. 인식 가능한 작업 또는 백그라운드 작업을 10~15초 동안 실행합니다.
  3. 재정의(adb shell am memory-limiter manual <PID> none)를 지운 다음 adb shell am start -W를 사용하여 앱을 즉시 다시 가져오고 TotalTime를 기록합니다. 대신 MemoryBudgetManager를 통해 후보를 설정하는 경우 앱이 반환되기 전에 clearProcessBudget를 호출합니다.
  4. 짧은 포그라운드 상호작용을 실행하고 통과 기준에 따라 리폴트 및 프레임 통계를 확인합니다.

앱이 해당 상태에 있고 웜 리턴 상태일 때 두 가지를 모두 통과하는 가장 낮은 예산을 선택하고 동일한 10% ~20% 의 여유를 추가합니다.

디스플레이 배율 보정

android:additionalBytesPerDisplayPixel를 사용하는 경우 해상도가 다른 두 디스플레이(예: 1080 × 2400(약 259만 픽셀) 및 1440 × 3120(약 449만 픽셀))에서 포그라운드 니를 찾습니다. 두 무릎의 차이(바이트)를 픽셀 수의 차이로 나누어 android:additionalBytesPerDisplayPixel를 구합니다. 더 작은 디스플레이의 픽셀당 값을 니에서 빼서 해상도 독립형 베이스를 얻고 헤드룸을 더해 android:maxMb를 얻습니다.

예산 테스트

새 예산 또는 더 엄격한 예산을 발표하기 전에 다음 사항을 확인하세요.

  • 출시 빌드: 테스트 환경 준비에 설명된 대로 출시하는 빌드를 테스트합니다.
  • 모든 예산 상태: 포그라운드, 인식 가능, 백그라운드 흐름을 실행하고 각 비포그라운드 예산의 웜 리턴을 검증합니다.
  • RAM이 부족한 기기: 지원되는 가장 낮은 RAM 등급의 기기를 하나 이상 포함합니다.
  • 창 크기: android:additionalBytesPerDisplayPixel를 사용하는 경우 전체 화면뿐만 아니라 분할 화면과 크기 조절이 가능한 창을 테스트합니다. 조정된 예산은 앱의 창 크기에서 계산되기 때문입니다.
  • 실제 데이터: 대규모 계정, 긴 목록, 많은 미디어 항목, 배송하는 언어로 테스트합니다. 추가 데이터로 인해 작업 세트가 증가하기 때문입니다.
  • 다중 프로세스 앱: 자체 <memory-budget> 절이 있는 각 프로세스를 실행합니다.
  • 회귀 게이트: 예산이 있는 경우와 없는 경우에 기존 Macrobenchmark 시작 및 버벅거림 테스트를 실행하고 예산이 있는 실행이 통과 기준을 초과하여 회귀하는 경우 테스트를 실패로 처리합니다.

단계별 예산 집행

MemoryBudgetManager를 통해 설정된 런타임 예산은 선언된 <memory-budget> 매니페스트 상한 내에서만 한도를 강화할 수 있습니다. 런타임에 매니페스트 예산을 늘릴 수 없습니다. AndroidManifest.xml에 공격적인 <memory-budget> 값을 제공하지 말고 서버 플래그에서 완화할 계획을 세우세요. 대신 다음 두 단계로 새 예산을 출시합니다.

  1. 원격 구성 뒤에서 검증: perceptible 또는 background 절 없이(권장) 또는 <memory-budget> 없이 하나의 넉넉한 <memory-budget> 안전 상한으로 APK를 제공합니다. 서버 측 실험 또는 원격 구성 플래그 뒤에 후보 예산을 게이트하고 ProcessLifecycleOwner 등을 통해 수명 주기 전환 전반에 걸쳐 타겟 상태의 예산을 적용합니다. 실험의 런타임 예산이 정적 또는 창 확장 매니페스트 상한 또는 RAM이 적은 기기의 시스템 메모리 한도를 초과할 때 발생하는 IllegalArgumentException를 포착합니다. catch 블록에서 clearProcessBudget 또는 clearPackageBudget를 호출하여 이전 상태의 더 엄격한 런타임 예산이 활성 상태로 유지되지 않도록 합니다. 예산이 이동할 수 있는 측정항목(프레임 시간, 시작 및 웜 재개 시간, CPU 시간, 배터리)에서 기기 RAM 등급별로 실험 부문을 비교합니다.
  2. 검증된 예산을 매니페스트로 승격: 필드 데이터에서 후보 예산이 기기 RAM 등급 전반에서 통과 기준을 충족하는 것으로 표시되면 안정 상태 foreground, perceptible, background 예산을 <memory-budget> 절로 이동합니다. 해당 버전을 단계적으로 출시하고 동일한 측정항목을 확인합니다.

런타임 검증 중에 원격 구성 플래그는 킬 스위치 역할을 합니다. 플래그를 사용 중지하면 새로 시작된 프로세스에서 런타임 예산 설정을 건너뛰고 clearProcessBudget 또는 clearPackageBudget를 호출하면 실행 중인 프로세스에서 활성 런타임 예산이 삭제됩니다. 앱은 앱 업데이트 없이 매니페스트 안전 상한으로 돌아가거나, 선언하지 않은 경우 앱 예산이 없는 상태로 돌아갑니다. 기기나 OS를 사용하여 예산을 사용 중지하는 대신 자체 앱 및 서버 구성에서 이 플래그를 유지합니다.

런타임에만 설정된 예산은 임시 출시 단계로 취급합니다. 매니페스트 예산은 서명된 APK 내에서 제공되며 앱 코드 없이 프로세스 시작부터 적용됩니다. 정적 <application> 선언만 읽는 PackageManager.getMemoryBudgets를 호출하여 앱을 실행하지 않고도 검사할 수 있습니다. 나중에 매니페스트 예산을 완화하려면 앱 업데이트가 필요하지만, 매니페스트 상한선 아래에서 런타임에 예산을 강화하는 실험을 계속 실행할 수 있습니다.