Android Low memory killer（上）

最新推荐文章于 2024-10-01 21:21:12 发布

dzhjsofo

最新推荐文章于 2024-10-01 21:21:12 发布

阅读量937

点赞数

分类专栏： android 文章标签： android struct module kill float server

android 专栏收录该内容

36 篇文章 0 订阅

订阅专栏

本文参照： http://blog.sina.com.cn/s/blog_4d66a3cb0100prfe.html

http://tech.it168.com/a2011/0805/1228/000001228471_2.shtml

Android中，进程的生命周期都是由系统控制的，即使用户关掉了程序，进程依然是存在于内存之中。这样设计的目的是为了下次能快速启动。当然，随着系统运行时间的增长，内存会越来越少。Android Kernel 会定时执行一次检查，杀死一些进程，释放掉内存。

那么，如何来判断，那些进程是需要杀死的呢？答案就是我们的标题：Low memory killer机制。

Android 的Low memory killer是基于linux的OOM（out of memory）规则改进而来的。 OOM通过一些比较复杂的评分机制，对进程进行打分，然后将分数高的进程判定为bad进程，杀死并释放内存。

Low memory killer 主要是通过进程的oom_adj 来判定进程的重要程度。oom_adj的大小和进程的类型以及进程被调度的次序有关。

对于 Android4.0以前， Low memory killer 的具体实现可参看： kernel/drivers/misc/lowmemorykiller.c

对于 Android4.0后， Low memory killer 的具体实现可参看： common/drivers/staging/lowmemorykiller.c

其原理很简单，在linux中，存在一个kswapd的内核线程，当linux回收存放分页的时候，kswapd线程将会遍历一张shrinker链表，并执行回调。shrinker是在中common\include\linux\mm.h定义的，定义如下：

* A callback you can register to apply pressure to ageable caches.

* 'sc' is passed shrink_control which includes a count 'nr_to_scan'

* and a 'gfpmask'. It should look through the least-recently-used

* 'nr_to_scan' entries and attempt to free them up. It should return

* the number of objects which remain in the cache. If it returns -1, it means

* it cannot do any scanning at this time (eg. there is a risk of deadlock).

* The 'gfpmask' refers to the allocation we are currently trying to

* fulfil.

* Note that 'shrink' will be passed nr_to_scan == 0 when the VM is

* querying the cache size, so a fastpath for that case is appropriate.

struct shrinker {

int (*shrink)(struct shrinker *, struct shrink_control *sc);

int seeks; /* seeks to recreate an obj */

/* These are for internal use */

struct list_head list;

long nr; /* objs pending delete */

};

#define DEFAULT_SEEKS 2 /* A good number if you don't know better. */

extern void register_shrinker (struct shrinker *);

extern void unregister_shrinker (struct shrinker *);

register_shrinker() 和 unregister_shrinker() 则是在 common\mm\Vmscan.c 中定义的

* Add a shrinker callback to be called from the vm

void register_shrinker (struct shrinker *shrinker)

{

shrinker->nr = 0;

down_write(&shrinker_rwsem);

list_add_tail(&shrinker->list, &shrinker_list);

up_write(&shrinker_rwsem);

}

EXPORT_SYMBOL(register_shrinker);

* Remove one

void unregister_shrinker (struct shrinker *shrinker)

{

down_write(&shrinker_rwsem);

list_del(&shrinker->list);

up_write(&shrinker_rwsem);

}

EXPORT_SYMBOL(unregister_shrinker);

static inline int do_shrinker_shrink (struct shrinker *shrinker,

struct shrink_control *sc,

unsigned long nr_to_scan)

{

sc->nr_to_scan = nr_to_scan;

return (*shrinker->shrink)(shrinker, sc);

}

所以只要注册一个Shrinker结构体，在内存分页回收时，系统将调用Shrinker结构体的函数指针

int (*shrink)(struct shrinker *, struct shrink_control *sc);,

下面我们来看看其实现Low memory killer的实现。

在 lowmemorykiller.c 中，首先定义一个以 lowmem_shrink 为回调函数的指针的shrinker结构体lowmem_shrinker

static struct shrinker lowmem_shrinker = {

.shrink = lowmem_shrink ,

.seeks = DEFAULT_SEEKS * 16

};

然后对 lowmem_shrink进行注册

static int __init lowmem_init (void)

{

task_free_register(&task_nb);

register_shrinker(&lowmem_shrinker);

return 0;

}

static void __exit lowmem_exit (void)

{

unregister_shrinker(&lowmem_shrinker);

task_free_unregister(&task_nb);

}

module_param_named(cost, lowmem_shrinker.seeks, int, S_IRUGO | S_IWUSR);

module_param_array_named(adj, lowmem_adj, int, &lowmem_adj_size,

S_IRUGO | S_IWUSR);

module_param_array_named(minfree, lowmem_minfree, uint, &lowmem_minfree_size,

S_IRUGO | S_IWUSR);

module_param_named(debug_level, lowmem_debug_level, uint, S_IRUGO | S_IWUSR);

module_init(lowmem_init);

module_exit(lowmem_exit);

通过 module_init(lowmem_init) 注册，在内存分页回收时，系统将调用 lowmem_shrink（）函数。

在 lowmemorykiller.c 中，定义了两对数组，以表示当系统内存低于某一值，就在低于某一优先级别的线程中，选择一占用内存最大的进程，然后杀死该进程，以释放其占用的内存。

这两对数组的定义如下：

static int lowmem_adj[6] = {

12,

};

static int lowmem_adj_size = 4;

static size_t lowmem_minfree[6] = {

3 * 512, /* 6MB */

2 * 1024, /* 8MB */

4 * 1024, /* 16MB */

16 * 1024, /* 64MB */

};

static int lowmem_minfree_size = 4;

这就说明，当系统的空闲空间下降到 16 * 1024 个页面时， oom_adj 值为 12 或者更大的进程将被 Kill 掉;当系统的空闲空间下降到 4 * 1024 个页面时， oom_adj 值为 6 或者更大的进程将被Kill掉；依此类推。

其实更简明就是说： task_struct->signal_struct->oom_adj 越大的越优先被Kill，

同 oom_adj 的进程占用物理内存最多的那个进程会被优先Kill。

进程描述符中的 signal_struct->oom_adj 表示当内存短缺时进程被选择并Kill的优先级，值越大越可能被选中。当某个进程被选中后，内核会发送SIGKILL信号将其Kill掉。

实际上， Low Memory Killer 驱动程序会认为被用于缓存的存储空间都要被释放，但是，如果很大一部分缓存存储空间处于被锁定的状态，那么这将是一个非常严重的错误，并且当正常的oom killer被触发之前，进程是不会被Kill掉的。

lowmem_adj 和 lowmem_minfree 上面的值只是个默认值，我们还可以通过以写文件的方式进行重写。我想该功能应该是通过 lowmemorykiller.c 中的如下代码开启该功能的

module_param_named (cost, lowmem_shrinker.seeks, int, S_IRUGO | S_IWUSR);

module_param_array_named ( adj , lowmem_adj , int, &lowmem_adj_size,

S_IRUGO | S_IWUSR);

module_param_array_named ( minfree , lowmem_minfree , uint, &lowmem_minfree_size,

S_IRUGO | S_IWUSR);

module_param_named ( debug_level , lowmem_debug_level , uint, S_IRUGO | S_IWUSR);

在Android4.0以前，一直是通过system/rootdir/init.rc进行重写，重写配置的，

比如：

# Define the oom_adj values for the classes of processes that can be

# killed by the kernel. These are used in ActivityManagerService.

setprop ro.FOREGROUND_APP_ADJ 0

setprop ro.VISIBLE_APP_ADJ 1

setprop ro.SECONDARY_SERVER_ADJ 2

setprop ro.BACKUP_APP_ADJ 2

setprop ro.HOME_APP_ADJ 4 //<category android:name="android.intent.category.HOME"/>

setprop ro.HIDDEN_APP_MIN_ADJ 7

setprop ro.CONTENT_PROVIDER_ADJ 14

setprop ro.EMPTY_APP_ADJ 15

# Define the memory thresholds at which the above process classes will

# be killed. These numbers are in pages (4k).

setprop ro.FOREGROUND_APP_MEM 1536

setprop ro.VISIBLE_APP_MEM 2048

setprop ro.SECONDARY_SERVER_MEM 4096

setprop ro.BACKUP_APP_MEM 4096

setprop ro.HOME_APP_MEM 4096

setprop ro.HIDDEN_APP_MEM 5120

setprop ro.CONTENT_PROVIDER_MEM 5632

setprop ro.EMPTY_APP_MEM 6144

# Write value must be consistent with the above properties.

# Note that the driver only supports 6 slots, so we have HOME_APP at the

# same memory level as services.

write /sys/ module/lowmemorykiller/parameters/ adj 0,1,2,7,14,15

write /proc/sys/vm/overcommit_memory 1

write /proc/sys/vm/min_free_order_shift 4

write /sys/ module/lowmemorykiller/parameters/ minfree 1536,2048,4096,5120,5632,6144

# Set init its forked children's oom_adj.

write /proc/1/oom_adj -16

在com.android.server.am.ActivityManagerService.java中，通过以下方式读取这些值。

可以在ActivityManagerService中清楚的看到：

static final int EMPTY_APP_ADJ;

static final int HIDDEN_APP_MAX_ADJ;

static final int HIDDEN_APP_MIN_ADJ;

static final int HOME_APP_ADJ;

static final int BACKUP_APP_ADJ;

static final int SECONDARY_SERVER_ADJ;

static final int HEAVY_WEIGHT_APP_ADJ;

static final int PERCEPTIBLE_APP_ADJ;

static final int VISIBLE_APP_ADJ;

static final int FOREGROUND_APP_ADJ;

static final int CORE_SERVER_ADJ = -12;

static final int SYSTEM_ADJ = -16;

ActivityManagerService定义各种进程的oom_adj,CORE_SERVER_ADJ代表一些核心的服务的omm_adj,数值为-12，由前面的分析可知道，这类进程永远也不会被杀死。

其他未赋值的都在static块中进行了初始化，是通过system/rootdir/init.rc进行配置的：

在Android4.0中，则是通过 com.android.server.am.ProcessList 进行重写，重行配置的.

摘要如下：

// These are the various interesting memory levels that we will give to

// the OOM killer. Note that the OOM killer only supports 6 slots, so we

// can't give it a different value for every possible kind of process.

private final int[] mOomAd j = new int[] {

FOREGROUND_APP_ADJ, VISIBLE_APP_ADJ, PERCEPTIBLE_APP_ADJ,

BACKUP_APP_ADJ, HIDDEN_APP_MIN_ADJ, EMPTY_APP_ADJ

};

// These are the low-end OOM level limits. This is appropriate for an

// HVGA or smaller phone with less than 512MB. Values are in KB.

private final long[] mOomMinFreeLow = new long[] {

8192, 12288, 16384,

24576, 28672, 32768

};

// These are the high-end OOM level limits. This is appropriate for a

// 1280x800 or larger screen with around 1GB RAM. Values are in KB.

private final long[] mOomMinFreeHigh = new long[] {

32768, 40960, 49152,

57344, 65536, 81920

};

...................................................................

ProcessList () {

MemInfoReader minfo = new MemInfoReader();

minfo.readMemInfo();

mTotalMemMb = minfo.getTotalSize()/(1024*1024);

updateOomLevels(0, 0, false);

}

..............................................................................

private void updateOomLevels(int displayWidth, int displayHeight, boolean write) {

// Scale buckets from avail memory: at 300MB we use the lowest values to

// 700MB or more for the top values.

float scaleMem = ((float)(mTotalMemMb-300))/(700-300);

// Scale buckets from screen size.

int minSize = 320*480; // 153600

int maxSize = 1280*800; // 1024000 230400 870400 .264

float scaleDisp = ((float)(displayWidth*displayHeight)-minSize)/(maxSize-minSize);

//Slog.i("XXXXXX", "scaleDisp=" + scaleDisp + " dw=" + displayWidth + " dh=" + displayHeight);

StringBuilder adjString = new StringBuilder();

StringBuilder memString = new StringBuilder();

float scale = scaleMem > scaleDisp ? scaleMem : scaleDisp;

if (scale < 0) scale = 0;

else if (scale > 1) scale = 1;

for (int i=0; i<mOomAdj.length; i++) {

long low = mOomMinFreeLow[i];

long high = mOomMinFreeHigh[i];

mOomMinFree[i] = (long)(low + ((high-low)*scale));

if (i > 0) {

adjString.append(',');

memString.append(',');

}

adjString.append(mOomAdj[i]);

memString.append((mOomMinFree[i]*1024)/PAGE_SIZE);

}

//Slog.i("XXXXXXX", "******************************* MINFREE: " + memString);

if (write) {

writeFile("/sys/module/lowmemorykiller/parameters/adj", adjString.toString());

writeFile("/sys/module/lowmemorykiller/parameters/minfree", memString.toString());

}

// GB: 2048,3072,4096,6144,7168,8192

// HC: 8192,10240,12288,14336,16384,20480

}

更多内容请阅读《 Android Low memory killer（下）》

dzhjsofo

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录