Android Q app内存压缩优化方案介绍

Android Q app内存压缩优化方案介绍

原创文章,谢绝转载!

Android Q新增了部分系统性能优化方案,这里简单学习下,本篇文章先分析app compaction。

一、愿景:

在保证后台进程尽量不被杀的基础上减少它们的内存占用。

二、思路:

AMS与Kernel层联动对满足一定条件的App进行内存压缩。
google官方样例数据:占用1.8G内存的游戏,压缩后只占700M。该功能在高端机上没有明显的卡顿和延迟。

三、源码分析

androidQ上,AMS中引入了OomAdjuster来统一管理oomadj相关逻辑。

frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

public ActivityManagerService(Injector injector, ServiceThread handlerThread) {
    ...
    mOomAdjuster = new OomAdjuster(this, mProcessList, activeUids);
    ...
}

在AMS构造方法中实例化OomAdjuster

OomAdjuster(ActivityManagerService service, ProcessList processList, ActiveUids activeUids) {
    ...
    mAppCompact = new AppCompactor(mService);
    ...
}

在OomAdjuster构造方法中实例化AppCompactor

void initSettings() {
    mAppCompact.init();
}

初始化mAppCompact

public final void installSystemProviders() {
    ...
    mOomAdjuster.initSettings();
    ...
}

接下来看看AppCompactor这个核心类
frameworks/base/services/core/java/com/android/server/am/AppCompactor.java

public AppCompactor(ActivityManagerService am) {
    mAm = am;
    mCompactionThread = new ServiceThread("CompactionThread",
            THREAD_PRIORITY_FOREGROUND, true);
    mProcStateThrottle = new HashSet<>();
}

创建了一个loop线程,并且优先级还挺高。

/**
* Reads phenotype config to determine whether app compaction is enabled or not and
* starts the background thread if necessary.
*/
public void init() {
    DeviceConfig.addOnPropertiesChangedListener(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER,
            ActivityThread.currentApplication().getMainExecutor(), mOnFlagsChangedListener);
    synchronized (mPhenotypeFlagLock) {
        updateUseCompaction();
        updateCompactionActions();
        updateCompactionThrottles();
        updateStatsdSampleRate();
        updateFullRssThrottle();
        updateFullDeltaRssThrottle();
        updateProcStateThrottle();
    }
    Process.setThreadGroupAndCpuset(mCompactionThread.getThreadId(),
            Process.THREAD_GROUP_SYSTEM);
}

做了一些初始化操作,例如::

/**
* Reads the flag value from DeviceConfig to determine whether app compaction
* should be enabled, and starts the compaction thread if needed.
*/
@GuardedBy("mPhenotypeFlagLock")
private void updateUseCompaction() {
    mUseCompaction = DeviceConfig.getBoolean(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER,
                KEY_USE_COMPACTION, DEFAULT_USE_COMPACTION);
    if (mUseCompaction && !mCompactionThread.isAlive()) {
        mCompactionThread.start();
        mCompactionHandler = new MemCompactionHandler();
    }
}

决定是否做压缩, 默认该功能没有打开。

下面来看看FW的核心压缩逻辑:
调用点在OomAdjuster的applyOomAdjLocked:

private final boolean applyOomAdjLocked(ProcessRecord app, boolean doingAll, long now,
        long nowElapsed) {
...
    //DeviceConfig配置决定它做压缩 同时系统已经完成booting
if (mAppCompact.useCompaction() && mService.mBooted) {
    // Cached and prev/home compaction
    if (app.curAdj != app.setAdj) {//当前adj有变化
        // Perform a minor compaction when a perceptible app becomes the prev/home app
        // Perform a major compaction when any app enters cached
        // reminder: here, setAdj is previous state, curAdj is upcoming state
        if (app.setAdj <= ProcessList.PERCEPTIBLE_APP_ADJ &&
                (app.curAdj == ProcessList.PREVIOUS_APP_ADJ ||
                        app.curAdj == ProcessList.HOME_APP_ADJ)) {
            [mAppCompact.compactAppSome(app);](http://mAppCompact.compactAppSome(app);)
        } else if ((app.setAdj < ProcessList.CACHED_APP_MIN_ADJ
                        || app.setAdj > ProcessList.CACHED_APP_MAX_ADJ)
                && app.curAdj >= ProcessList.CACHED_APP_MIN_ADJ
                && app.curAdj <= ProcessList.CACHED_APP_MAX_ADJ) {
            [mAppCompact.compactAppFull(app);](http://mAppCompact.compactAppFull(app);)
        }
    } else if (mService.mWakefulness != PowerManagerInternal.WAKEFULNESS_AWAKE
            && app.setAdj < ProcessList.FOREGROUND_APP_ADJ
            // Because these can fire independent of oom_adj/procstate changes, we need
            // to throttle the actual dispatch of these requests in addition to the
            // processing of the requests. As a result, there is throttling both here
            // and in AppCompactor.
            && mAppCompact.shouldCompactPersistent(app, now)) {
        [mAppCompact.compactAppPersistent(app);](http://mAppCompact.compactAppPersistent(app);)
    } else if (mService.mWakefulness != PowerManagerInternal.WAKEFULNESS_AWAKE
            && app.getCurProcState()
                == ActivityManager.PROCESS_STATE_BOUND_FOREGROUND_SERVICE
            && mAppCompact.shouldCompactBFGS(app, now)) {
        [mAppCompact.compactAppBfgs(app);](http://mAppCompact.compactAppBfgs(app);)
    }
}
...
}

逻辑总结:

  • 可感知进程变为PREVIOUS(700)或HOME(600)进程,则执行compactAppSome,做一次minor compaction。

  • 非cache进程进入到cache区间:CACHE_MAX(999)-CACHE_MIN(900)之间,则执行compactAppFull,做一次major compaction。

  • 当前手机是非awake状态且进程优先级高于前台,并且满足shouldCompactPersistent逻辑:即当前进程从来没压缩过,或者距离上次压缩时间>10min.则执行compactAppPersistent。

  • 当前手机是非awake状态且进程有前台服务,并且满足shouldCompactBFGS逻辑,与shouldCompactPersistent一致。则执行compactAppBfgs。

对应的这几个方法:

@GuardedBy("mAm")
void compactAppSome(ProcessRecord app) {
    app.reqCompactAction = COMPACT_PROCESS_SOME;
    mPendingCompactionProcesses.add(app);
    mCompactionHandler.sendMessage(
        mCompactionHandler.obtainMessage(
            COMPACT_PROCESS_MSG, app.setAdj, app.setProcState));
}

@GuardedBy("mAm")
void compactAppFull(ProcessRecord app) {
    app.reqCompactAction = COMPACT_PROCESS_FULL;
    mPendingCompactionProcesses.add(app);
    mCompactionHandler.sendMessage(
        mCompactionHandler.obtainMessage(
            COMPACT_PROCESS_MSG, app.setAdj, app.setProcState));
}

@GuardedBy("mAm")
void compactAppPersistent(ProcessRecord app) {
    app.reqCompactAction = COMPACT_PROCESS_PERSISTENT;
    mPendingCompactionProcesses.add(app);
    mCompactionHandler.sendMessage(
            mCompactionHandler.obtainMessage(
                COMPACT_PROCESS_MSG, app.curAdj, app.setProcState));
}

@GuardedBy("mAm")
void compactAppBfgs(ProcessRecord app) {
    app.reqCompactAction = COMPACT_PROCESS_BFGS;
    mPendingCompactionProcesses.add(app);
    mCompactionHandler.sendMessage(
            mCompactionHandler.obtainMessage(
                COMPACT_PROCESS_MSG, app.curAdj, app.setProcState));
}

另外这里还有一个方法需要关注下,它的调用在AMS的finishBooting()

@GuardedBy("mAm")
void compactAllSystem() {
    if (mUseCompaction) {
        mCompactionHandler.sendMessage(mCompactionHandler.obtainMessage(
                                          COMPACT_SYSTEM_MSG));
    }
}

发送消息

private final class MemCompactionHandler extends Handler {
    private MemCompactionHandler() {
        super(mCompactionThread.getLooper());
    }
    @Override
    public void handleMessage(Message msg) {
        switch (msg.what) {
            case COMPACT_PROCESS_MSG: {
                long start = SystemClock.uptimeMillis();
                ProcessRecord proc;
                int pid;
                String action;
                final String name;
                int pendingAction, lastCompactAction;
                long lastCompactTime;
                LastCompactionStats lastCompactionStats;
                int lastOomAdj = msg.arg1;
                int procState = msg.arg2;
                synchronized (mAm) {
                    proc = mPendingCompactionProcesses.remove(0);
                    pendingAction = proc.reqCompactAction;
                    pid = proc.pid;
                    name = proc.processName;
                    // don't compact if the process has returned to perceptible
                    // and this is only a cached/home/prev compaction
                    if ((pendingAction == COMPACT_PROCESS_SOME
                            || pendingAction == COMPACT_PROCESS_FULL)
                            && (proc.setAdj <= ProcessList.PERCEPTIBLE_APP_ADJ)) {
                        if (DEBUG_COMPACTION) {
                            Slog.d(TAG_AM,
                                    "Skipping compaction as process " + name + " is "
                                    + "now perceptible.");
                        }
                        return;
                    }
                    lastCompactAction = proc.lastCompactAction;
                    lastCompactTime = proc.lastCompactTime;
                    // remove rather than get so that insertion order will be updated when we
                    // put the post-compaction stats back into the map.
                    lastCompactionStats = mLastCompactionStats.remove(pid);
                }
                if (pid == 0) {
                    // not a real process, either one being launched or one being killed
                    return;
                }
                // basic throttling
                // use the Phenotype flag knobs to determine whether current/prevous
                // compaction combo should be throtted or not
                // Note that we explicitly don't take mPhenotypeFlagLock here as the flags
                // should very seldom change, and taking the risk of using the wrong action is
                // preferable to taking the lock for every single compaction action.
                if (lastCompactTime != 0) {
                    if (pendingAction == COMPACT_PROCESS_SOME) {
                        if ((lastCompactAction == COMPACT_PROCESS_SOME
                                && (start - lastCompactTime < mCompactThrottleSomeSome))
                                || (lastCompactAction == COMPACT_PROCESS_FULL
                                    && (start - lastCompactTime
                                            < mCompactThrottleSomeFull))) {
                            if (DEBUG_COMPACTION) {
                                Slog.d(TAG_AM, "Skipping some compaction for " + name
                                        + ": too soon. throttle=" + mCompactThrottleSomeSome
                                        + "/" + mCompactThrottleSomeFull + " last="
                                        + (start - lastCompactTime) + "ms ago");
                            }
                            return;
                        }
                    } else if (pendingAction == COMPACT_PROCESS_FULL) {
                        if ((lastCompactAction == COMPACT_PROCESS_SOME
                                && (start - lastCompactTime < mCompactThrottleFullSome))
                                || (lastCompactAction == COMPACT_PROCESS_FULL
                                    && (start - lastCompactTime
                                            < mCompactThrottleFullFull))) {
                            if (DEBUG_COMPACTION) {
                                Slog.d(TAG_AM, "Skipping full compaction for " + name
                                        + ": too soon. throttle=" + mCompactThrottleFullSome
                                        + "/" + mCompactThrottleFullFull + " last="
                                        + (start - lastCompactTime) + "ms ago");
                            }
                            return;
                        }
                    } else if (pendingAction == COMPACT_PROCESS_PERSISTENT) {
                        if (start - lastCompactTime < mCompactThrottlePersistent) {
                            if (DEBUG_COMPACTION) {
                                Slog.d(TAG_AM, "Skipping persistent compaction for " + name
                                        + ": too soon. throttle=" + mCompactThrottlePersistent
                                        + " last=" + (start - lastCompactTime) + "ms ago");
                            }
                            return;
                        }
                    } else if (pendingAction == COMPACT_PROCESS_BFGS) {
                        if (start - lastCompactTime < mCompactThrottleBFGS) {
                            if (DEBUG_COMPACTION) {
                                Slog.d(TAG_AM, "Skipping bfgs compaction for " + name
                                        + ": too soon. throttle=" + mCompactThrottleBFGS
                                        + " last=" + (start - lastCompactTime) + "ms ago");
                            }
                            return;
                        }
                    }
                }
                //这里action最终只分为了两种:
                //some对应"file"
                //full、presistent、bfgs都对应"all"
                switch (pendingAction) {
                    case COMPACT_PROCESS_SOME:
                        action = mCompactActionSome;
                        break;
                    // For the time being, treat these as equivalent.
                    case COMPACT_PROCESS_FULL:
                    case COMPACT_PROCESS_PERSISTENT:
                    case COMPACT_PROCESS_BFGS:
                        action = mCompactActionFull;
                        break;
                    default:
                        action = COMPACT_ACTION_NONE;
                        break;
                }
                if (COMPACT_ACTION_NONE.equals(action)) {
                    return;
                }
                if (mProcStateThrottle.contains(procState)) {
                    if (DEBUG_COMPACTION) {
                        Slog.d(TAG_AM, "Skipping full compaction for process " + name
                                + "; proc state is " + procState);
                    }
                    return;
                }
                long[] rssBefore = Process.getRss(pid);
                long anonRssBefore = rssBefore[2];
                if (rssBefore[0] == 0 && rssBefore[1] == 0 && rssBefore[2] == 0
                        && rssBefore[3] == 0) {
                    if (DEBUG_COMPACTION) {
                        Slog.d(TAG_AM, "Skipping compaction for" + "process " + pid
                                + " with no memory usage. Dead?");
                    }
                    return;
                }
                if (action.equals(COMPACT_ACTION_FULL) || action.equals(COMPACT_ACTION_ANON)) {
                    if (mFullAnonRssThrottleKb > 0L
                            && anonRssBefore < mFullAnonRssThrottleKb) {
                        if (DEBUG_COMPACTION) {
                            Slog.d(TAG_AM, "Skipping full compaction for process "
                                    + name + "; anon RSS is too small: " + anonRssBefore
                                    + "KB.");
                        }
                        return;
                    }
                    if (lastCompactionStats != null && mFullDeltaRssThrottleKb > 0L) {
                        long[] lastRss = lastCompactionStats.getRssAfterCompaction();
                        long absDelta = Math.abs(rssBefore[1] - lastRss[1])
                                + Math.abs(rssBefore[2] - lastRss[2])
                                + Math.abs(rssBefore[3] - lastRss[3]);
                        if (absDelta <= mFullDeltaRssThrottleKb) {
                            if (DEBUG_COMPACTION) {
                                Slog.d(TAG_AM, "Skipping full compaction for process "
                                        + name + "; abs delta is too small: " + absDelta
                                        + "KB.");
                            }
                            return;
                        }
                    }
                }
                // Now we've passed through all the throttles and are going to compact, update
                // bookkeeping.
                switch (pendingAction) {
                    case COMPACT_PROCESS_SOME:
                        mSomeCompactionCount++;
                        break;
                    case COMPACT_PROCESS_FULL:
                        mFullCompactionCount++;
                        break;
                    case COMPACT_PROCESS_PERSISTENT:
                        mPersistentCompactionCount++;
                        break;
                    case COMPACT_PROCESS_BFGS:
                        mBfgsCompactionCount++;
                        break;
                    default:
                        break;
                }
                try {
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "Compact "
                            + ((pendingAction == COMPACT_PROCESS_SOME) ? "some" : "full")
                            + ": " + name);
                    long zramFreeKbBefore = Debug.getZramFreeKb();
                    //在/proc/pid/reclaim文件中写入节点值
                    FileOutputStream fos = new FileOutputStream("/proc/" + pid + "/reclaim");
                    fos.write(action.getBytes());
                    fos.close();
                    long[] rssAfter = Process.getRss(pid);
                    long end = SystemClock.uptimeMillis();
                    long time = end - start;
                    long zramFreeKbAfter = Debug.getZramFreeKb();
                    EventLog.writeEvent(EventLogTags.AM_COMPACT, pid, name, action,
                            rssBefore[0], rssBefore[1], rssBefore[2], rssBefore[3],
                            rssAfter[0] - rssBefore[0], rssAfter[1] - rssBefore[1],
                            rssAfter[2] - rssBefore[2], rssAfter[3] - rssBefore[3], time,
                            lastCompactAction, lastCompactTime, lastOomAdj, procState,
                            zramFreeKbBefore, zramFreeKbAfter - zramFreeKbBefore);
                    // Note that as above not taking mPhenoTypeFlagLock here to avoid locking
                    // on every single compaction for a flag that will seldom change and the
                    // impact of reading the wrong value here is low.
                    if (mRandom.nextFloat() < mStatsdSampleRate) {
                        StatsLog.write(StatsLog.APP_COMPACTED, pid, name, pendingAction,
                                rssBefore[0], rssBefore[1], rssBefore[2], rssBefore[3],
                                rssAfter[0], rssAfter[1], rssAfter[2], rssAfter[3], time,
                                lastCompactAction, lastCompactTime, lastOomAdj,
                                ActivityManager.processStateAmToProto(procState),
                                zramFreeKbBefore, zramFreeKbAfter);
                    }
                    synchronized (mAm) {
                        proc.lastCompactTime = end;
                        proc.lastCompactAction = pendingAction;
                    }
                    if (action.equals(COMPACT_ACTION_FULL)
                            || action.equals(COMPACT_ACTION_ANON)) {
                        mLastCompactionStats.put(pid, new LastCompactionStats(rssAfter));
                    }
                } catch (Exception e) {
                    // nothing to do, presumably the process died
                } finally {
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                }
                break;
            }
            case COMPACT_SYSTEM_MSG: {
                Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "compactSystem");
                compactSystem();//native方法
                Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                break;
            }
        }
    }
}

compactSystem是个native方法,对应JNI如下:

frameworks/base/services/core/jni/com_android_server_am_AppCompactor.cpp
// This performs per-process reclaim on all processes belonging to non-app UIDs.
// For the most part, these are non-zygote processes like Treble HALs, but it
// also includes zygote-derived processes that run in system UIDs, like bluetooth
// or potentially some mainline modules. The only process that should definitely
// not be compacted is system_server, since compacting system_server around the
// time of BOOT_COMPLETE could result in perceptible issues.
static void com_android_server_am_AppCompactor_compactSystem(JNIEnv *, jobject) {
    std::unique_ptr proc(opendir("/proc"), closedir);
    struct dirent* current;
    while ((current = readdir(proc.get()))) {
        if (current->d_type != DT_DIR) {
            continue;
        }
        // don't compact system_server, rely on persistent compaction during screen off
        // in order to avoid mmap_sem-related stalls
        if (atoi(current->d_name) == getpid()) {
            continue;
        }
        std::string status_name = StringPrintf("/proc/%s/status", current->d_name);
        struct stat status_info;
        if (stat(status_name.c_str(), &status_info) != 0) {
            // must be some other directory that isn't a pid
            continue;
        }
        // android.os.Process.FIRST_APPLICATION_UID
        if (status_info.st_uid >= 10000) {
            continue;
        }
        std::string reclaim_path = StringPrintf("/proc/%s/reclaim", current->d_name);
        WriteStringToFile(std::string("all"), reclaim_path); //写all
    }
}

FW逻辑总结:

  • 应用进程:
    一系列判断和赋值之后,在/proc/pid/reclaim文件中写入action,
    这里action主要看两种:
    some对应"file"
    full、presistent、bfgs都对应"all"

  • 非应用进程(除system_server):
    在/proc/pid/reclaim文件中写入”all"

FW最终写了节点,那么接下来看看kernel的逻辑:

kernel/msm-4.19/fs/proc/base.c
#ifdef CONFIG_PROCESS_RECLAIM
   REG("reclaim", 0200, proc_reclaim_operations),
#endif

注册节点执行proc_reclaim_operations

kernel/msm-4.19/fs/proc/task_mmu.c
const struct file_operations proc_reclaim_operations = {

   .write    = reclaim_write,

   .llseek       = noop_llseek,

};

在节点write操作后,对应会触发reclaim_write

static ssize_t reclaim_write(struct file *file, const char __user *buf,
            size_t count, loff_t *ppos)
{
   struct task_struct *task;//进程
   char buffer[200];
   struct mm_struct *mm;//内存
   struct vm_area_struct *vma;//虚拟内存区域
   enum reclaim_type type;//回收类型: RECLAIM_FILE, RECLAIM_ANON, RECLAIM_ALL, RECLAIM_RANGE,
   char *type_buf;
   struct mm_walk reclaim_walk = {};
   unsigned long start = 0;//起始
   unsigned long end = 0;//结尾
   struct reclaim_param rp;
   int ret;
   memset(buffer, 0, sizeof(buffer));//为新申请内存进行初始化
   if (count > sizeof(buffer) - 1)
      count = sizeof(buffer) - 1;
   if (copy_from_user(buffer, buf, count))
      return -EFAULT;
   //从FW传进来的内容看:目前只有file 和 all两种,这里就是解析对应的回收类型。
   type_buf = strstrip(buffer);
   if (!strcmp(type_buf, "file"))
      type = RECLAIM_FILE;//文件页
   else if (!strcmp(type_buf, "anon"))
      type = RECLAIM_ANON;//匿名页
   else if (!strcmp(type_buf, "all"))
      type = RECLAIM_ALL;
   else if (isdigit(*type_buf))
      type = RECLAIM_RANGE;
   else
      goto out_err;
   if (type == RECLAIM_RANGE) {
      char *token;
      unsigned long long len, len_in, tmp;
      token = strsep(&type_buf, " ");
      if (!token)
         goto out_err;
      tmp = memparse(token, &token);
      if (tmp & ~PAGE_MASK || tmp > ULONG_MAX)
         goto out_err;
      start = tmp;
      token = strsep(&type_buf, " ");
      if (!token)
         goto out_err;
      len_in = memparse(token, &token);
      len = (len_in + ~PAGE_MASK) & PAGE_MASK;
      if (len > ULONG_MAX)
         goto out_err;
      /*
       * Check to see whether len was rounded up from small -ve
       * to zero.
       */
      if (len_in && !len)
         goto out_err;
      end = start + len;
      if (end < start)
         goto out_err;
   }
   task = get_proc_task(file->f_path.dentry->d_inode);//获取进程
   if (!task)
      return -ESRCH;
   mm = get_task_mm(task);//获取进程的内存struct
   if (!mm)
      goto out;
   [reclaim_walk.mm](http://reclaim_walk.mm) = mm;
   reclaim_walk.pmd_entry = reclaim_pte_range;//最终触发回收
   rp.nr_to_reclaim = INT_MAX;
   rp.nr_reclaimed = 0;
   reclaim_walk.private = &rp;
   down_read(&mm->mmap_sem);//读信号量
   if (type == RECLAIM_RANGE) {
      vma = find_vma(mm, start);
      while (vma) {
         if (vma->vm_start > end)
            break;
         if (is_vm_hugetlb_page(vma))
            continue;
         rp.vma = vma;
         ret = walk_page_range(max(vma->vm_start, start),
               min(vma->vm_end, end),
               &reclaim_walk);
         if (ret)
            break;
         vma = vma->vm_next;
      }
   } else {
      //遍历当前进程所占用的虚拟地址
      for (vma = mm->mmap; vma; vma = vma->vm_next) {
         if (is_vm_hugetlb_page(vma))
            continue;
         if (type == RECLAIM_ANON && vma->vm_file)//anon对应回收匿名页
            continue;
         if (type == RECLAIM_FILE && !vma->vm_file)//file对应回收文件页
            continue;
         rp.vma = vma;
         //walk_page_range的功能就是遍历页表,并调用回调函数进行处理,回调函数都是定义在mm_walk中。
         ret = walk_page_range(vma->vm_start, vma->vm_end,
            &reclaim_walk);
         if (ret)
            break;
      }
   }
   flush_tlb_mm(mm);
   up_read(&mm->mmap_sem);
   mmput(mm);
out:
   put_task_struct(task);
   return count;
out_err:
   return -EINVAL;
}

walk_page_range最终会回调到:reclaim_walk.pmd_entry,而它会触发执行reclaim_pte_range

#ifdef CONFIG_PROCESS_RECLAIM
int reclaim_pte_range(pmd_t *pmd, unsigned long addr,
            unsigned long end, struct mm_walk *walk)
{
   struct reclaim_param *rp = walk->private;
   struct vm_area_struct *vma = rp->vma;
   pte_t *pte, ptent;
   spinlock_t *ptl;
   struct page *page;
   LIST_HEAD(page_list);
   int isolated;
   int reclaimed;
   split_huge_pmd(vma, addr, pmd);
   if (pmd_trans_unstable(pmd) || !rp->nr_to_reclaim)
      return 0;
cont:
   isolated = 0;
   pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);
   for (; addr != end; pte++, addr += PAGE_SIZE) {
      ptent = *pte;
      if (!pte_present(ptent))
         continue;
      page = vm_normal_page(vma, addr, ptent);
      if (!page)
         continue;
      if (page_mapcount(page) != 1)
         continue;
      if (isolate_lru_page(page))
         continue;
      /* MADV_FREE clears pte dirty bit and then marks the page
       * lazyfree (clear SwapBacked). Inbetween if this lazyfreed page
       * is touched by user then it becomes dirty.  PPR in
       * shrink_page_list in try_to_unmap finds the page dirty, marks
       * it back as PageSwapBacked and skips reclaim. This can cause
       * isolated count mismatch.
       */
      if (PageAnon(page) && !PageSwapBacked(page)) {
         putback_lru_page(page);
         continue;
      }

      list_add(&page->lru, &page_list);
      inc_node_page_state(page, NR_ISOLATED_ANON +
            page_is_file_cache(page));
      isolated++;
      rp->nr_scanned++;
      if ((isolated >= SWAP_CLUSTER_MAX) || !rp->nr_to_reclaim)
         break;
   }
   pte_unmap_unlock(pte - 1, ptl);
   //最终调用reclaim_pages_from_list来触发回收
   reclaimed = reclaim_pages_from_list(&page_list, vma);
   rp->nr_reclaimed += reclaimed;
   rp->nr_to_reclaim -= reclaimed;
   if (rp->nr_to_reclaim < 0)
      rp->nr_to_reclaim = 0;
   if (rp->nr_to_reclaim && (addr != end))
      goto cont;
   cond_resched();
   return (rp->nr_to_reclaim == 0) ? -EPIPE : 0;
}

最终调用:

#ifdef CONFIG_PROCESS_RECLAIM
unsigned long reclaim_pages_from_list(struct list_head *page_list,
               struct vm_area_struct *vma)
{
   struct scan_control sc = {
      .gfp_mask = GFP_KERNEL,
      .priority = DEF_PRIORITY,
      .may_writepage = 1,
      .may_unmap = 1,
      .may_swap = 1,
      .target_vma = vma,
   };
   unsigned long nr_reclaimed;
   struct page *page;
   list_for_each_entry(page, page_list, lru)
      ClearPageActive(page);
   nr_reclaimed = shrink_page_list(page_list, NULL, &sc,
         TTU_IGNORE_ACCESS, NULL, true);
   while (!list_empty(page_list)) {
      page = lru_to_page(page_list);
      list_del(&page->lru);
      dec_node_page_state(page, NR_ISOLATED_ANON +
            page_is_file_cache(page));
      putback_lru_page(page);
   }
   return nr_reclaimed;
}
#endif

到shrink_page_list,这就很明显了,根据lru触发page页回收,后面就不继续跟了。

进程的内存管理

总结:
app compaction 是以进程为单位触发文件页、匿名页回收的内存优化策略,上层FW提供优化的进程依据。该策略在kernel很早就已经有了,只是到Android Q才开始在FW上层做逻辑,AOSP该功能目前是默认关闭的,并且策略稍显简单,可以研究下自定义一些策略。

对应kernel patch:
Michan Kim
https://lore.kernel.org/patchwork/patch/688100/

原文地址:https://www.jianshu.com/p/ae4ca096201a

你可能感兴趣的:(Android Q app内存压缩优化方案介绍)