[Android] [AOSP] LMK进程优先级策略

一、什么是LMK

在AOSP中，Low Memory Killer（LMK）是一种内存管理机制，它根据进程的优先级来决定哪些进程应该被终止以释放内存。这个机制通过内核任务（kswapd）来实现，该任务不断扫描内存使用情况，并在内存不足时触发LMK机制。在LMK机制中，每个进程都被分配了一个优先级，当内存不足时，系统会根据进程的优先级选择性地终止某些进程，以释放更多的内存。

二、进程优先级策略

/**
     * Set the out-of-memory badness adjustment for a process.
     * If {@code pid <= 0}, this method will be a no-op.
     *
     * @param pid The process identifier to set.
     * @param uid The uid of the app
     * @param amt Adjustment value -- lmkd allows -1000 to +1000
     *
     * {@hide}
     */
    public static void setOomAdj(int pid, int uid, int amt) {
        // This indicates that the process is not started yet and so no need to proceed further.
        if (pid <= 0) {
            return;
        }
        if (amt == UNKNOWN_ADJ)
            return;

        long start = SystemClock.elapsedRealtime();
        ByteBuffer buf = ByteBuffer.allocate(4 * 4);
        buf.putInt(LMK_PROCPRIO);
        buf.putInt(pid);
        buf.putInt(uid);
        buf.putInt(amt);
        writeLmkd(buf, null);
        long now = SystemClock.elapsedRealtime();
        if ((now-start) > 250) {
            Slog.w("ActivityManager", "SLOW OOM ADJ: " + (now-start) + "ms for pid " + pid
                    + " = " + amt);
        }
    }

可以通过ProcessList.java中的setOomAdj方法去调整进程的优先级， OOM_ADJ （Out-Of-Memory Adjustment），进程优先级影响系统对进程的内存回收策略。OOM_ADJ 值越低，表示该进程的优先级越高，系统回收内存时越不会杀死该进程。OOM_ADJ 值越高，则表示该进程的优先级越低，系统回收内存时越容易杀死该进程。

在 Android 中，OOM_ADJ 值的范围为 -1000 到 1000，其中 -1000 表示最高优先级（最不容易被杀死），而 1000 表示最低优先级（最容易被杀死）。具体来说，-1000 到 -900 被认为是“前台进程”；-800 到 0 被认为是“可见进程”；而 1000 则被认为是“空进程”。

关于 -1000 和 1000 优先级的区别，主要体现在它们所代表的进程类型不同。具体来说：

• 1000 优先级的进程是属于前台进程，这些进程通常是用户当前正在操作的应用程序。这些进程可以使用大量的系统资源，并且在系统内存不足时也不容易被杀死。因此，系统会尽量保留这些进程的内存，以保证用户体验的流畅性。
• 1000 优先级的进程是属于空进程，即没有任何应用程序或服务的进程。这些进程不占用任何内存，因此在系统内存不足时，它们往往会被最先杀死。因此，这些进程通常只会被用来占位，或者用来作为一些系统服务的容器。

三、LowerMemoryKill日志分析（AM策略）

Line 2813: S000AFC 07-25 09:35 ActivityManager: Killing process com.example.app (adj 975)：**empty** for 2011s
Line 2813: S000AFC 07-25 09:35 ActivityManager: Killing process com.example.app (adj 900)：**remove task**
Line 2813: S000AFC 07-25 09:35 ActivityManager: Killing process com.example.app (adj 910)：**stop xx due to from pid 1xx**
Line 2813: S000AFC 07-25 09:35 ActivityManager: Killing process com.example.app (adj 965)：**rampolicy available memory:1001**

可以从日志上看到进程被kill的原因（am kill），有进程优先级，900~1000都属于要被kill的对象，例如empty原因，也就是empty对象达到上限，好像是10来个，就会触发empty kill。

再例如rampolicy原因，由内存策略进行的一个kill，应该是低内存原因

四、系统服务为什么被Kiil后能自起？

ProcessRecord newProcessRecordLocked(ApplicationInfo info, String customProcess,
            boolean isolated, int isolatedUid, HostingRecord hostingRecord) {
        String proc = customProcess != null ? customProcess : info.processName;
        final int userId = UserHandle.getUserId(info.uid);
        int uid = info.uid;
        if (isolated) {
            ...
        **final ProcessRecord r = new ProcessRecord(mService, info, proc, uid);**
        final ProcessStateRecord state = r.mState;

        **if (!mService.mBooted && !mService.mBooting
                && userId == UserHandle.USER_SYSTEM
                && (info.flags & PERSISTENT_MASK) == PERSISTENT_MASK) {
            // The system process is initialized to SCHED_GROUP_DEFAULT in init.rc.
            state.setCurrentSchedulingGroup(ProcessList.SCHED_GROUP_DEFAULT);
            state.setSetSchedGroup(ProcessList.SCHED_GROUP_DEFAULT);
            r.setPersistent(true);
            state.setMaxAdj(ProcessList.PERSISTENT_PROC_ADJ);
        }**
        ...
        addProcessNameLocked(r);
        return r;
    }

以上代码是应用的启动流程，也是系统进程的启动流程，如果发现是系统服务，也就是**userId == UserHandle.USER_SYSTEM,并且applicationInfo（应用可以在AndroidManifest.xml中配置）带有PERSISTENT_MASK相关flag，就会将ProcessRecord（一个进程存在一个该实例），设置为持久进程：r.setPersistent(true);**

再来看看进程被kill的代码，AMS中调用forceStopPackage，killProcess进行杀进程，然后调用到ProcessList#removeProcessLocked，方法如下

boolean removeProcessLocked(ProcessRecord app, boolean callerWillRestart,
            boolean allowRestart, int reasonCode, int subReason, String reason) {
        final String name = app.processName;
        final int uid = app.uid;
	      ...
        boolean needRestart = false;
        final int pid = app.getPid();
        if ((pid > 0 && pid != ActivityManagerService.MY_PID)
                || (pid == 0 && app.isPendingStart())) {
            ...
            boolean willRestart = false;
            Log.d(TAG, "removeProcessLocked: KeepAliveManager app:"+app.processName
                    +",isPersistent:"+app.isPersistent()+",app.isolated:"+app.isolated);
            if (**app.isPersistent()** && !app.isolated) {
                if (!callerWillRestart) {
                    **willRestart = true;**
                } else {
                    **needRestart = true;**
                }
            }
            app.killLocked(reason, reasonCode, subReason, true);
            mService.handleAppDiedLocked(app, pid, willRestart, allowRestart,
                    false /* fromBinderDied */);
            **if (willRestart)** {
                removeLruProcessLocked(app);
                **mService.addAppLocked(app.info, null, false, null /* ABI override */,
                        ZYGOTE_POLICY_FLAG_EMPTY);**
            }
        } else {
            mRemovedProcesses.add(app);
        }

        return needRestart;
    }

应用被杀的流程，会检查是否是持久进程，也就是**app.isPersistent()，如果是则会将willRestart置为true，从而触发mService.addAppLocked**，去启动应用（也就是重新走进程启动流程，会回到最开始的newProcessRecordLocked方法）

五、查看进程调整adj的日志

💡 1.adb shell cat /data/system/packages.list可以查看每个进程的uid 2.db shell am watch-uids --oom {uid}就可以观察adj调整的记录了