查看adj
可以通过命令:
adb shell
//筛选进程
ps | grep <包名|pid>
//然后,其中oom_score_adj是内核计算过后的adj
cat proc/<pid>/oom_score_adj
方法2
adb shell
dumpsys activity o
//然后查看
ProcessRecord中下面这些属性反应了oom_score_adj的值
int maxAdj; // Maximum OOM adjustment for this process
int curRawAdj; // Current OOM unlimited adjustment for this process
int setRawAdj; // Last set OOM unlimited adjustment for this process
int curAdj; // Current OOM adjustment for this process
int setAdj; // Last set OOM adjustment for this process
其中:
- maxAdj 指定了该进程允许的oom_score_adj最大值(主要给系统应用和常驻内存使用,通过maxAdj保证这些进程拥有较高优先级)
- curXXX这一组记录了这一次优先级计算的结果,会将curXXX复制给对应的setXXX这一组上进行备份。
- xxxRawAdj记录了没有经过限制的adj值,“没有经过限制”是指这其中的值可能是超过了oom_score_adj文件所允许的范围(-1000 ~ 1000)
- ProcessList.Java中预定义了oom_score_adj的可能取值。
static final int UNKNOWN_ADJ = 1001; // 未知进程
static final int PREVIOUS_APP_ADJ = 700; // 前一个应用
static final int HOME_APP_ADJ = 600; // 桌面进程
static final int SERVICE_ADJ = 500; // 包含了Service的进程
static final int HEAVY_WEIGHT_APP_ADJ = 400; // 重量级进程
static final int BACKUP_APP_ADJ = 300; // 备份应用进程
static final int PERCEPTIBLE_APP_ADJ = 200; // 可感知的进程
static final int VISIBLE_APP_ADJ = 100; // 可见进程
static final int VISIBLE_APP_LAYER_MAX = PERCEPTIBLE_APP_ADJ - VISIBLE_APP_ADJ - 1;
static final int FOREGROUND_APP_ADJ = 0; // 前台进程
static final int PERSISTENT_SERVICE_ADJ = -700; // 常驻服务进程
static final int PERSISTENT_PROC_ADJ = -800; // 常驻应用进程
static final int SYSTEM_ADJ = -900; // 系统进程
static final int NATIVE_ADJ = -1000; // native系统进程
解释上面这些可能的情况:
- FOREGROUND_APP_ADJ = 0,这个是前台应用进程的优先级,正在和用户交互的进程(普通应用获得的最高优先级)
- VISIBLE_APP_ADJ是具有可见Activity进程的优先级,前台的Activity设置透明,或者小窗口后面的Activity也可见这种情况
- PERCEPTIBLE_APP_ADJ是指用户可感知的进程,可感知的进程包括:
1.进程中包含了处于pause状态或者正在pause的Activity
2.进程中包含了正在stop的Activity
3.进程中包含了前台的Service
- PREVIOUS_APP_ADJ描述的是前一个应用的优先级。在启动新的Activity时,如果新启动的Activity是属于一个新的进程的,那么当前即将被stop的Activity所在的进程便会成为“前一个应用”进程。
- HEAVY_WEIGHT_APP_ADJ 描述的重量级进程是指那些通过Manifest指明不能保存状态的应用进程。
- PERSISTENT_SERVICE_ADJ = -700,PERSISTENT_PROC_ADJ = -800,系统中的一些进程,比如System_ADJ,NATIVE_ADJ=-1000
进程分类
- 前台进程 (Foreground process)
- 包含用户正在交互的 Activity(已调用 Activity 的 onResume() 方法)
- 包含某个 Service,后者绑定到用户正在交互的 Activity
- 包含正在“前台”运行的 Service(已调用 startForeground())
- 包含正执行一个生命周期回调的 Service(onCreate()、onStart() 或 onDestroy())
- 包含正执行其 onReceive() 方法的 BroadcastReceiver
- 可见进程(Visible process)
- 不再前台,但对前台有影响,比如如果前台 Activity 启动了一个对话框,允许在其后显示上一 Activity,则有可能会发生这种情况。
- 托管绑定到可见(或前台)Activity 的 Service
- 服务进程 (Service process)
- 使用startservice()方法启动服务,服务与可见内容没直接关联(下载,播放音乐等)属于可感知
- 后台进程 (Background process)
- 不可见的Activity进程(调用onStop()方法)这类进程保存在LRU列表中。
- 空进程 (Empty process)
- 不包含任何活动应用组件的进程。目的是通过应用缓存进程,而不浪费时间在启动新的进程。
Android中进程管理的机制
platform/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java)
platform/frameworks/base/services/core/java/com/android/server/am/ProcessList.java
platform/system/core/lmkd/lmkd.c
kernel/common/drivers/staging/Android/lowmemorykiller.c
通过输入命令:
adb shell
dumpsys activity o
查看有关进程状态
Android m
杀进程与阶段对应
对应在ProcessList.java
中定义
级别 | 常量名称 | 内存大小 | 简述 |
---|---|---|---|
-16 | SYSTEM_ADJ | 61440 kB | 系统进程 |
-12 | PERSISTENT_PROC_ADJ | 61440 kB | 系统persistent进程,比如telephony |
-11 | PERSISTENT_SERVICE_ADJ | 61440 kB | 关联着系统或persistent进程 |
0 | FOREGROUND_APP_ADJ | 61440 kB | 前台进程(Foreground process |
1 | VISIBLE_APP_ADJ | 76800 kB | 可见进程(Visible process) |
2 | PERCEPTIBLE_APP_ADJ | 92160 kB | 可感知进程,比如后台音乐播放 |
3 | BACKUP_APP_ADJ | 107520 kB | 备份进程 |
4 | HEAVY_WEIGHT_APP_ADJ | 137660 kB | 后台的重量级进程,system/rootdir/init.rc文件中设置 |
5 | SERVICE_ADJ | 137660 kB | 服务进程(Service process) |
6 | HOME_APP_ADJ | 137660 kB | Home进程 |
7 | PREVIOUS_APP_ADJ | 137660 kB | 上一个App的进程(往往通过按返回键) |
8 | SERVICE_B_ADJ | 137660 kB | List中的Service(较老的、使用可能性更小) |
9 | CACHED_APP_MIN_ADJ | 137660 kB | 不可见进程的adj最小值 |
15 | CACHED_APP_MAX_ADJ | 174948 kB | 不可见进程的adj最大值 |
Android n
杀进程与阶段对应
对应在ProcessList.java
中定义
级别 | 常量名称 | 内存大小 | lmk杀进程根据adj6档 |
---|---|---|---|
-900 | SYSTEM_ADJ | 73,728k | |
-800 | PERSISTENT_PROC_ADJ | 73,728K | |
-700 | PERSISTENT_SERVICE_ADJ | 73,728K | |
0 | FOREGROUND_APP_ADJ | 73,728K | + |
100 | VISIBLE_APP_ADJ | 92,160K | + |
200 | PERCEPTIBLE_APP_ADJ | 110,592K | + |
300 | BACKUP_APP_ADJ | 129,024K | + |
400 | HEAVY_WEIGHT_APP_ADJ | 221,184K | |
500 | SERVICE_ADJ | 221,184K | |
600 | HOME_APP_ADJ | 221,184K | |
700 | PREVIOUS_APP_ADJ | 221,184K | |
800 | SERVICE_B_ADJ | 221,184K | |
900 | CACHED_APP_MIN_ADJ | 221,184K | + |
906 | CACHED_APP_MAX_ADJ | 322,560K | + |
Process state(m and n)
对应在ActivityManager中定义一下几种进程的状态
state级别 | 取值 | 解释 | 优先级(大于state)return IMPORTANCE_XXX |
---|---|---|---|
PROCESS_STATE_CACHED_EMPTY | 16 | 进程处于cached状态,且为空进程 | 400 |
PROCESS_STATE_CACHED_ACTIVITY_CLIENT | 15 | 进程处于cached状态,且为另一个cached进程(内含Activity)的client进程 | 400 |
PROCESS_STATE_CACHED_ACTIVITY | 14 | 进程处于cached状态,且内含Activity | 400 |
PROCESS_STATE_LAST_ACTIVITY | 13 | 后台进程,且拥有上一次显示的Activity | 400 |
PROCESS_STATE_HOME | 12 | 后台进程,且拥有home Activity | 400 |
PROCESS_STATE_RECEIVER | 11 | 后台进程,且正在运行receiver | 300 |
PROCESS_STATE_SERVICE | 10 | 后台进程,且正在运行service | 300 |
PROCESS_STATE_HEAVY_WEIGHT | 9 | 后台进程,但无法执行restore,因此尽量避免kill该进程 | 170 |
PROCESS_STATE_BACKUP | 8 | 后台进程,正在运行backup/restore操作 | 130 |
PROCESS_STATE_IMPORTANT_BACKGROUND | 7 | 对用户很重要的进程,用户不可感知其存在 | 130 |
PROCESS_STATE_IMPORTANT_FOREGROUND | 6 | 对用户很重要的进程,用户可感知其存在 | 200 |
PROCESS_STATE_TOP_SLEEPING | 5 | 与PROCESS_STATE_TOP一样,但此时设备正处于休眠状态 | 150 |
PROCESS_STATE_FOREGROUND_SERVICE | 4 | 拥有给一个前台Service | 125 |
PROCESS_STATE_BOUND_FOREGROUND_SERVICE | 3 | 拥有给一个前台Service,且由系统绑定 | 100 |
PROCESS_STATE_TOP | 2 | 拥有当前用户可见的top Activity | 100 |
PROCESS_STATE_PERSISTENT_UI | 1 | persistent系统进程,并正在执行UI操作 | 100 |
PROCESS_STATE_PERSISTENT | 0 | persistent系统进程 | 100 |
PROCESS_STATE_NONEXISTENT | -1 | 不存在的进程 | 1000 |
进程优先级定义
在 ActivityManager 中的 RunningAppProcessInfo 类中定义了进程的优先级 IMPORTANCE 值
/**
* Constant for {@link #importance}: This process is running the
* foreground UI; that is, it is the thing currently at the top of the screen
* that the user is interacting with.
*/
public static final int IMPORTANCE_FOREGROUND = 100;
/**
* Constant for {@link #importance}: This process is running a foreground
* service, for example to perform music playback even while the user is
* not immediately in the app. This generally indicates that the process
* is doing something the user actively cares about.
*/
public static final int IMPORTANCE_FOREGROUND_SERVICE = 125;
/**
* Constant for {@link #importance}: This process is running the foreground
* UI, but the device is asleep so it is not visible to the user. This means
* the user is not really aware of the process, because they can not see or
* interact with it, but it is quite important because it what they expect to
* return to once unlocking the device.
*/
public static final int IMPORTANCE_TOP_SLEEPING = 150;
/**
* Constant for {@link #importance}: This process is running something
* that is actively visible to the user, though not in the immediate
* foreground. This may be running a window that is behind the current
* foreground (so paused and with its state saved, not interacting with
* the user, but visible to them to some degree); it may also be running
* other services under the system's control that it inconsiders important.
*/
public static final int IMPORTANCE_VISIBLE = 200;
/**
* Constant for {@link #importance}: This process is not something the user
* is directly aware of, but is otherwise perceptable to them to some degree.
*/
public static final int IMPORTANCE_PERCEPTIBLE = 130;
/**
* Constant for {@link #importance}: This process is running an
* application that can not save its state, and thus can't be killed
* while in the background.
* @hide
*/
public static final int IMPORTANCE_CANT_SAVE_STATE = 170;
/**
* Constant for {@link #importance}: This process is contains services
* that should remain running. These are background services apps have
* started, not something the user is aware of, so they may be killed by
* the system relatively freely (though it is generally desired that they
* stay running as long as they want to).
*/
public static final int IMPORTANCE_SERVICE = 300;
/**
* Constant for {@link #importance}: This process process contains
* background code that is expendable.
*/
public static final int IMPORTANCE_BACKGROUND = 400;
/**
* Constant for {@link #importance}: This process is empty of any
* actively running code.
*/
public static final int IMPORTANCE_EMPTY = 500;
/**
* Constant for {@link #importance}: This process does not exist.
*/
public static final int IMPORTANCE_GONE = 1000;
/** @hide */
public static int procStateToImportance(int procState) {
if (procState == PROCESS_STATE_NONEXISTENT) {
return IMPORTANCE_GONE;
} else if (procState >= PROCESS_STATE_HOME) {
return IMPORTANCE_BACKGROUND;
} else if (procState >= PROCESS_STATE_SERVICE) {
return IMPORTANCE_SERVICE;
} else if (procState > PROCESS_STATE_HEAVY_WEIGHT) {
return IMPORTANCE_CANT_SAVE_STATE;
} else if (procState >= PROCESS_STATE_IMPORTANT_BACKGROUND) {
return IMPORTANCE_PERCEPTIBLE;
} else if (procState >= PROCESS_STATE_IMPORTANT_FOREGROUND) {
return IMPORTANCE_VISIBLE;
} else if (procState >= PROCESS_STATE_TOP_SLEEPING) {
return IMPORTANCE_TOP_SLEEPING;
} else if (procState >= PROCESS_STATE_FOREGROUND_SERVICE) {
return IMPORTANCE_FOREGROUND_SERVICE;
} else {
return IMPORTANCE_FOREGROUND;
}
}
根据上面代码可知进程的优先级和进程的状态挂钩,每一个状态对应一种优先级。
AMS中有三个核心方法
- updateOomAdjLocked:更新adj,当目标进程为空,或者被杀则返回false;否则返回true;
- computeOomAdjLocked:计算adj,返回计算后RawAdj值;
- applyOomAdjLocked:应用adj,当需要杀掉目标进程则返回false;否则返回true。
updateOomAdjLocked 中会调用 computeOomAdjLocked 和 applyOomAdjLocked。
LowMemoryKiller 的阈值的设定
阈值的设定
- /sys/module/lowmemorykiller/parameters/adj
- /sys/module/lowmemorykiller/parameters/minfree
shamu:/ # cat /sys/module/lowmemorykiller/parameters/adj
0,100,200,300,900,906
shamu:/ # cat /sys/module/lowmemorykiller/parameters/minfree
18432,23040,27648,32256,36864,46080
minfree中数值的单位是内存中的页面数量,一般情况下一个页面是4KB。
例如:将1,6写入节点/sys/module/lowmemorykiller/parameters/adj,将1024,8192写入节点/sys/module/lowmemorykiller/parameters/minfree。
策略:当系统可用内存低于8192个pages时,则会杀掉oom_score_adj>=6的进程;当系统可用内存低于1024个pages时,则会杀掉oom_score_adj>=1的进程。
lmkd 守护进程
system/core/lmkd/lmkd.c
lmkd创建名称为lmkd的socket,节点位于/dev/socket/lmkd,接受命令如下:
功能 | 命令 | 对应方法 |
---|---|---|
LMK_PROCPRIO | 设置进程adj | PL.setOomAdj() |
LMK_TARGET | 更新oom_adj | PL.updateOomLevels() |
LMK_PROCREMOVE | 移除进程 | PL.remove() |
设置adj
- 向节点/proc//oom_score_adj写入oom_adj。
framework与lmkd对应方法:
static void ctrl_command_handler(void) {
int ibuf[CTRL_PACKET_MAX / sizeof(int)];
int len;
int cmd = -1;
int nargs;
int targets;
len = ctrl_data_read((char *)ibuf, CTRL_PACKET_MAX);
if (len <= 0)
return;
nargs = len / sizeof(int) - 1;
if (nargs < 0)
goto wronglen;
//将网络字节顺序转换为主机字节顺序
cmd = ntohl(ibuf[0]);
switch(cmd) {
case LMK_TARGET:
targets = nargs / 2;
if (nargs & 0x1 || targets > (int)ARRAY_SIZE(lowmem_adj))
goto wronglen;
cmd_target(targets, &ibuf[1]);
break;
case LMK_PROCPRIO:
if (nargs != 3)
goto wronglen;
//设置进程adj
cmd_procprio(ntohl(ibuf[1]), ntohl(ibuf[2]), ntohl(ibuf[3]));
break;
case LMK_PROCREMOVE:
if (nargs != 1)
goto wronglen;
cmd_procremove(ntohl(ibuf[1]));
break;
default:
ALOGE("Received unknown command code %d", cmd);
return;
}
return;
wronglen:
ALOGE("Wrong control socket read length cmd=%d len=%d", cmd, len);
}
- LMK_TARGET:AMS.updateConfiguration()的过程中调用updateOomLevels()方法, 分别向/sys/module/lowmemorykiller/parameters目录下的minfree和adj节点写入相应信息;
- LMK_PROCPRIO: AMS.applyOomAdjLocked()的过程中调用setOomAdj(),向/proc//oom_score_adj写入oomadj 后直接返回;
- LMK_PROCREMOVE:AMS.handleAppDiedLocked或者 AMS.cleanUpApplicationRecordLocked()的过程,调用remove(),目前不做任何事,直接返回;
LowMemoryKiller Kernel driver
lowmemorykiller driver
位于drivers/staging/android/lowmemorykiller.c
核心在于:通过 register_shrinker
和unregister_shrinker
分别用于初始化和退出。
LMK通过注册shrinker
来实现。其中shrinker
是Linux kernel标准的回收page的机制,由内核线程kswapd负责监控。
核心思想是
- 选择oom_score_adj最大的进程中,并且rss内存最大的进程作为选中要杀的进程。
- 杀进程方式:send_sig(SIGKILL, selected, 0)向选中的目标进程发送signal 9来杀掉目标进程。
内部使用:
lmkd参数
- oom_adj:代表进程的优先级, 数值越大,优先级越低,越容易被杀. 取值范围[-16, 15]
- oom_score_adj: 取值范围[-1000, 1000]
- oom_score:lmk策略中貌似并没有看到使用的地方,这个应该是oom才会使用。
lowmem_oom_adj_to_oom_score_adj 计算:
//OOM_SCORE_ADJ_MAX=1000
//OOM_DISABLE=-17
static int lowmem_oom_adj_to_oom_score_adj(int oom_adj)
{
if (oom_adj == OOM_ADJUST_MAX)
return OOM_SCORE_ADJ_MAX;
else
return (oom_adj * OOM_SCORE_ADJ_MAX) / -OOM_DISABLE;
}
- 当oom_adj = 15, 则 oom_score_adj = 1000;
- 当oom_adj < 15, 则 oom_score_adj = oom_adj * 1000/17;
小结
- 系统framework根据不同类型进程生命周期控制,动态分配不同的adj,并在不同时机进行更新。
- 更新adj时候在framework层会和lmkd守护进程进行通信,修改lmk deiver配置参数,设置/proc/pid/oom_score_adj;
- lowmemorykiller 驱动会被 linux 内核的内存 shrinker 机制调度,在 shrinker 操作中,计算进程 adj 和 rss,依据 driver 的 oom_adj 和 minfree 配置,进行 kill 进程操作