linux内存管理-页面回收之内核线程 kswapd (二)

上面章节将kswapd内核线程的整理逻辑体现出来了,本节将介绍其中的很多细节函数。

1、balance_pgdat函数

balance_pgdat函数是回收页面的主函数。这个函数比较长,查看时可以先看整体框架。

复制代码
/*负责在指定NUMA节点上回收内存,直至满足分配请求或达到回收上限*/
static unsigned long balance_pgdat(pg_data_t *pgdat, int order/*期望分配的连续物理页阶数*/,
			int *classzone_idx/*输入为本次分配请求涉及的最高内存域,输出为本次回收实际触及的最高内存域*/)
{
	int i;
	/*本次回收需要扫描的最高zone索引*/
	int end_zone = 0;	/* Inclusive.  0 = ZONE_DMA */
	unsigned long nr_soft_reclaimed;
	unsigned long nr_soft_scanned;

	/*linux内核内存回收子系统中的核心控制结构,它封装了一次内存回收操作的所有控制参数和结果统计*/
	struct scan_control sc = {
		.gfp_mask = GFP_KERNEL,
		.order = order, /*目标分配阶*/
		.priority = DEF_PRIORITY, /*扫描优先级,初始值12,越低越激进*/
		.may_writepage = !laptop_mode, /*是否允许回写脏页*/
		.may_unmap = 1, /*是否允许解除页面映射,为1允许解除映射回收存在映射的页面*/
		.may_swap = 1,  /*是否允许交换页面,为1允许使用swap分区*/
	};
	count_vm_event(PAGEOUTRUN);

	do {
		/*统计在当前优先级下,尝试回收页面的总次数,用于判断是否需要进行内存规整*/
		unsigned long nr_attempted = 0;
		/*标志位,指示是否需要提高回收优先级(即变得更激进)*/
		bool raise_priority = true;
		/*标志位,指示本次回收是否需要考虑内存规整,order>0就需要内存规则*/
		bool pgdat_needs_compaction = (order > 0);

		/*回收页面数置零*/
		sc.nr_reclaimed = 0;

		/*
		 * Scan in the highmem->dma direction for the highest
		 * zone which needs scanning
		 */
		/*
			第一轮扫描,确定回收范围end_zone
			从高端zone向低端zone反向扫描,这是为了与内核内存分配器从高到低查找zone的顺序匹配,避免重复扫描
		*/

		for (i = pgdat->nr_zones - 1; i >= 0; i--) {
			struct zone *zone = pgdat->node_zones + i;

			if (!populated_zone(zone)) /*zone是否为空*/
				continue;

			/*
				当回收压力增大(priority降低)时,跳过那些被标记为不可回收的zone(如ZONE_MOVABLE)
			*/
			if (sc.priority != DEF_PRIORITY &&
			    !zone_reclaimable(zone)/*zone无需再进行回收*/)
				continue;

			/*
			 * Do some background aging of the anon list, to give
			 * pages a chance to be referenced before reclaiming.
			 */
			/*对匿名页的活跃LRU链表进行"老化"处理,非活跃匿名页面较少时,将部分(最多32个)活跃页面移至非活跃链表,为回收做准备*/
			age_active_anon(zone, &sc);

			/*
			 * If the number of buffer_heads in the machine
			 * exceeds the maximum allowed level and this node
			 * has a highmem zone, force kswapd to reclaim from
			 * it to relieve lowmem pressure.
			 */
			/*
			这是一个特殊优化。
			buffer_head是内核中用于管理块设备缓冲区的核心数据结构(定义在<linux/buffer_head.h>),主要关联文件系统的元数据(如inode、目录项)和磁盘块的缓存,
			每个buffer_head对应一个磁盘块(通常512B~4KB),用于跟踪缓冲区的状态(如脏页、锁定、I/O进度等)
			当系统buffer_heads过多且有高端内存时,强制从高端内存回收,以缓解低端内存压力。
			如果触发,则设置end_zone并跳出循环
			*/
			if (buffer_heads_over_limit && is_highmem_idx(i)) {
				end_zone = i;
				break;
			}

			/*
			调用zone_balanced()检查当前zone的水位是否满足order阶分配的需求后仍为高水位值
			如果不满足​(!zone_balanced),说明此zone及其之下的所有zone都需要回收,记录end_zone = i并跳出循环
			如果满足​(zone_balanced),说明此zone内存充足,清除其ZONE_CONGESTED(拥塞)和ZONE_DIRTY(脏页)标志,表示无需特殊处理
			*/
			if (!zone_balanced(zone, order, 0/*balance_gap为0*/, 0)) {
				end_zone = i;
				break;
			} else {
				/*
				 * If balanced, clear the dirty and congested
				 * flags
				 */
				clear_bit(ZONE_CONGESTED, &zone->flags);
				clear_bit(ZONE_DIRTY, &zone->flags);
			}
		}

		if (i < 0) /*如果上一轮扫描未找到任何不平衡的zone(i=-1),说明整个节点内存充足,直接跳转到out退出*/
			goto out;

		/*
		第二轮扫描,判断是否需要内存规整
		*/
		/*从低端zone向高端zone正向扫描,遍历所有需要回收的zone*/
		for (i = 0; i <= end_zone; i++) {
			struct zone *zone = pgdat->node_zones + i;

			if (!populated_zone(zone))
				continue;

			/*
			 * If any zone is currently balanced then kswapd will
			 * not call compaction as it is expected that the
			 * necessary pages are already available.
			 */
			/*
			如果仍需规整,但发现某个zone的内存水位已达到低水位​(low_wmark_pages),则认为该zone有足够的空闲页面,无需规整。
			将pgdat_needs_compaction置为false
			*/
			if (pgdat_needs_compaction &&
					zone_watermark_ok(zone, order,
						low_wmark_pages(zone),
						*classzone_idx, 0))
				pgdat_needs_compaction = false;
		}

		/*
		 * If we're getting trouble reclaiming, start doing writepage
		 * even in laptop mode.
		 */
		/*
		当回收优先级变得很低(即回收压力大)时,强制开启sc.may_writepage,即使在省电的laptop_mode下也允许回写脏页,以释放更多内存
		*/
		if (sc.priority < DEF_PRIORITY - 2)
			sc.may_writepage = 1; /*回收压力大,允许回写操作,回收脏页*/

		/*
		 * Now scan the zone in the dma->highmem direction, stopping
		 * at the last zone which needs scanning.
		 *
		 * We do this because the page allocator works in the opposite
		 * direction.  This prevents the page allocator from allocating
		 * pages behind kswapd's direction of progress, which would
		 * cause too much scanning of the lower zones.
		 */
		/*
		第三轮扫描,执行实际回收
		*/
		/*再次从低端向高端扫描,对end_zone及以下的每个zone执行回收*/
		for (i = 0; i <= end_zone; i++) {
			struct zone *zone = pgdat->node_zones + i;

			if (!populated_zone(zone))
				continue;

			if (sc.priority != DEF_PRIORITY &&
			    !zone_reclaimable(zone))
				continue;

			/*重置本轮对该zone的扫描页面计数*/
			sc.nr_scanned = 0;

			nr_soft_scanned = 0;
			/*
			 * Call soft limit reclaim before calling shrink_zone.
			 */
			/*优先对超出cgroup软限制的页面进行回收,并更新回收统计*/
			nr_soft_reclaimed = mem_cgroup_soft_limit_reclaim(zone,
							order, sc.gfp_mask,
							&nr_soft_scanned);
			sc.nr_reclaimed += nr_soft_reclaimed;

			/*
			 * There should be no need to raise the scanning
			 * priority if enough pages are already being scanned
			 * that that high watermark would be met at 100%
			 * efficiency.
			 */
			/*
			调用kswapd_shrink_zone()对当前zone执行核心回收逻辑。
			如果回收效果显著,则将raise_priority置为false,表示无需再提高优先级
			*/
			if (kswapd_shrink_zone(zone, end_zone,
					       &sc, &nr_attempted))
				raise_priority = false;
		}

		/*
		 * If the low watermark is met there is no need for processes
		 * to be throttled on pfmemalloc_wait as they should not be
		 * able to safely make forward progress. Wake them
		 */
		/*
		 检查是否有进程因内存紧张而在pfmemalloc_wait队列上等待,并且系统整体内存水位是否已恢复到安全水平
		*/
		if (waitqueue_active(&pgdat->pfmemalloc_wait) &&
				pfmemalloc_watermark_ok(pgdat))
			wake_up_all(&pgdat->pfmemalloc_wait); /*如果条件满足,则唤醒所有等待的进程,让它们可以继续执行*/

		/*
		 * Fragmentation may mean that the system cannot be rebalanced
		 * for high-order allocations in all zones. If twice the
		 * allocation size has been reclaimed and the zones are still
		 * not balanced then recheck the watermarks at order-0 to
		 * prevent kswapd reclaiming excessively. Assume that a
		 * process requested a high-order can direct reclaim/compact.
		 */
		/*
		如果请求的是高阶内存(order > 0),但回收的页面数已远超需求(2^order的两倍),说明内存碎片严重,难以分配连续内存
		回收量达标但合并失败,已回收页面数达到2^order+1页(目标阶数的2倍),却仍无法形成order阶连续块,说明碎片过多无法合并
		*/
		if (order && sc.nr_reclaimed >= 2UL << order)
			order = sc.order = 0; /*将目标阶数降级为0,转为优先保证基础内存(单页)的充足,避免过度回收*/

		/*检查退出条件*/
		/* Check if kswapd should be suspending */
		if (try_to_freeze() || kthread_should_stop())
			break;

		/*
		 * Compact if necessary and kswapd is reclaiming at least the
		 * high watermark number of pages as requsted
		 */
		/*触发内存规整*/
		/*
		如果仍需规整,并且回收的页面数超过了尝试回收的次数(说明回收有效),则调用compact_pgdat()对该节点执行内存规整,以整理内存碎片
		*/
		if (pgdat_needs_compaction && sc.nr_reclaimed > nr_attempted)
			compact_pgdat(pgdat, order);

		/*
		 * Raise priority if scanning rate is too low or there was no
		 * progress in reclaiming pages
		 */
		/*
		如果本轮回收效果不佳(未回收足够页面),则降低sc.priority的值(提高扫描激进程度)
		*/
		if (raise_priority || !sc.nr_reclaimed)
			sc.priority--;
	} while (sc.priority >= 1 && !pgdat_balanced(pgdat, order, *classzone_idx));
		/*当回收优先级降至1以下,或整个节点的内存已满足order阶分配需求时,循环结束*/
out:
	/*
	 * Return the order we were reclaiming at so prepare_kswapd_sleep()
	 * makes a decision on the order we were last reclaiming at. However,
	 * if another caller entered the allocator slow path while kswapd
	 * was awake, order will remain at the higher level
	 */
	/*将本次回收实际触及的最高zone索引写回,供kswapd下次唤醒时使用*/
	*classzone_idx = end_zone;
	return order; /*返回本次回收后,kswapd认为可以满足的最高分配阶*/
}

整体循环的退出条件,当回收优先级降至1以下,或整个节点的内存已满足order阶分配需求时,循环结束。

复制代码
/*判断一个内存节点(Node)是否"平衡",即其管理的所有相关内存区域(Zone)的空闲内存是否充足*/
static bool pgdat_balanced(pg_data_t *pgdat, int order, int classzone_idx)
{
	/*累计节点内所有受伙伴系统管理的页面总数*/
	unsigned long managed_pages = 0;
	/*累计节点内已处于"平衡"状态的页面数量*/
	unsigned long balanced_pages = 0;
	int i;

	/* Check the watermark levels */
	for (i = 0; i <= classzone_idx; i++) {
		struct zone *zone = pgdat->node_zones + i;

		if (!populated_zone(zone)) /*跳过空 Zone*/
			continue;

		/*统计节点内所有zone 伙伴系统管理的页面数量 managed_pages的数量*/
		managed_pages += zone->managed_pages;

		/*
		 * A special case here:
		 *
		 * balance_pgdat() skips over all_unreclaimable after
		 * DEF_PRIORITY. Effectively, it considers them balanced so
		 * they must be considered balanced here as well!
		 */
		/*
		特殊情况,处理不可回收Zone,对于标记为all_unreclaimable的Zone(如ZONE_MOVABLE在内存紧张时),balance_pgdat()回收逻辑会直接跳过它们,
		因此,这里也将其视为"平衡"状态,并将其所有页面计入balanced_pages,以避免kswapd在此类Zone上做无用功
		*/
		if (!zone_reclaimable(zone)) { /*不可回收zone*/
			balanced_pages += zone->managed_pages;
			continue;
		}

		/*判断当前Zone在分配2^order个页面下是否满足水位线要求且能提供order阶的连续内存*/
		if (zone_balanced(zone, order, 0, i))
			balanced_pages += zone->managed_pages; /*若平衡,将该Zone的所有页面计入balanced_pages*/
		else if (!order) /*若不平衡且order为0,对于单页分配,要求所有Zone都必须平衡,一旦发现不平衡的Zone,立即返回false,表示节点不平衡*/
			return false;
	}

	/*
	根据order的值返回最终的平衡判断
	高阶分配(order > 0),只要"平衡"的页面总数balanced_pages不少于总管理页面数managed_pages的25%(managed_pages >> 2),
		就认为节点整体是平衡的。这是一个权衡,避免因个别Zone不平衡而过度回收。
	单页分配(order == 0),由于前面已确保所有Zone都平衡,此处直接返回true
	*/
	if (order)
		return balanced_pages >= (managed_pages >> 2);
	else
		return true;
}

pgdat_balanced()需要注意参数classzone_idx,它表示在页面分配路径上计算出来第一个最合适内存分配的zone的编号,通过wake_all_kswapds()传递下来。

复制代码
判断zone是否能够进行回收的标准就是扫描次数是否>= 可回收页面的总数*6(匿名页+文件页),如果zone中页面之前被扫描的次数足够多再次扫描意义不大
/*
true(可回收),表示已扫描的页面数相对较少,回收工作尚不充分,zone仍被认为是可回收的
false(不可回收),表示已扫描的页面数过多,但回收效果不佳,说明大部分页面可能已"僵死"或难以回收,zone被视为"基本不可回收"
*/
bool zone_reclaimable(struct zone *zone)
{
	/*
	该机制旨在避免在可回收页面还很多时,因少量扫描失败就过早放弃回收,
	乘以6意味着,内核允许扫描的页面数是可回收页面总数的6倍,这被认为是一个合理的上限。
	6这个阈值是在特定内核版本和负载下,通过大量实验确定的"甜点值",
	后续版本的内核虽然对此逻辑有过重构,但*6这个经验阈值的核心思想被保留了下来
	*/
	return zone_page_state(zone, NR_PAGES_SCANNED)/*内存回收过程中,累计扫描过的页面总数*/ <
		zone_reclaimable_pages(zone) * 6; /*统计一个内存区域(zone)中当前"真正可回收"的页面总数 *6*/

}

/*
统计一个内存区域(zone)中当前"真正可回收"的页面总数,包括文件页和(在有Swap时)匿名页
*/
static unsigned long zone_reclaimable_pages(struct zone *zone)
{
	int nr;

	/*
	活跃文件页数量+非活跃文件页数量
	*/
	nr = zone_page_state(zone, NR_ACTIVE_FILE) +
	     zone_page_state(zone, NR_INACTIVE_FILE);

	/*
	文件页与磁盘文件关联,回收时可直接丢弃(对于干净页)或写回文件(脏页),因此不依赖swap​即可回收
	匿名页没有对应的磁盘文件(如进程堆、栈),回收时必须将其内容写入Swap空间才能释放物理内存
	如果系统中没有可用的swap(get_nr_swap_pages() == 0),匿名页就无法被回收,将它们计入"可回收页面"总数会严重误导内存管理决策
	*/
	if (get_nr_swap_pages() > 0) /*可用swap页面总数*/
		nr += zone_page_state(zone, NR_ACTIVE_ANON) +
		      zone_page_state(zone, NR_INACTIVE_ANON); /*活跃匿名页数量+非活跃匿名页数量*/


	return nr;
}

注意,zone中可回收页面的统计中对于匿名页面的统计比较特殊,如果设备中无swap分区/文件,那么匿名页面的回收就会存在问题,匿名页面是不纳入可回收页面统计范围内。

/*
内核中kswapd后台线程进行内存回收时,专门处理匿名页老化的函数
其逻辑是,当系统中有swap空间,且某个内存区域(zone)的非活跃匿名页(Inactive Anon)数量过少时,
从活跃匿名页(Active Anon)链表尾部迁移一批页面(32)到非活跃链表,为后续的回收做准备
*/
static void age_active_anon(struct zone *zone, struct scan_control *sc)
{
	struct mem_cgroup *memcg;

	/*total_swap_pages记录系统中Swap空间的物理总大小(所有可用页面数)*/
	if (!total_swap_pages) /*无swap分区则直接返回,无处理活跃匿名页*/
		return;

	memcg = mem_cgroup_iter(NULL, NULL, NULL);
	do {
		struct lruvec *lruvec = mem_cgroup_zone_lruvec(zone, memcg);

		if (inactive_anon_is_low(lruvec)) /*非活跃匿名页面数量<活跃匿名页面数量*/
			/*将活跃匿名链表尾部"可能不再活跃"的页面挑出来,根据访问情况决定,仍然活跃的放回active,不再活跃的移到inactive*/
			shrink_active_list(SWAP_CLUSTER_MAX/*32,本次要从active LRU中扫描多少页**/, lruvec,
					   sc, LRU_ACTIVE_ANON/*活跃匿名页面*/);

		memcg = mem_cgroup_iter(NULL, memcg, NULL);
	} while (memcg);
}

判断zone中非活跃页面的数量和活跃页面数量之间的关系,非活跃页面数量<活跃页面数量认为inactive is low,

这时可以将活跃链表中近期未被访问的页面放到非活跃链表上,为后续的回收做准备。

复制代码
/**
 * inactive_anon_is_low - check if anonymous pages need to be deactivated
 * @lruvec: LRU vector to check
 *
 * Returns true if the zone does not have enough inactive anon pages,
 * meaning some active anon pages need to be deactivated.
 */
static int inactive_anon_is_low(struct lruvec *lruvec)
{
	/*
	 * If we don't have swap space, anonymous page deactivation
	 * is pointless.
	 */
	if (!total_swap_pages) /*无swapu分区就无法进行匿名页的回收*/
		return 0;

	if (!mem_cgroup_disabled())
		return mem_cgroup_inactive_anon_is_low(lruvec);

	/*判断非活跃匿名页面和活跃匿名页面之间的关系*/
	return inactive_anon_is_low_global(lruvec_zone(lruvec));
}

static int inactive_anon_is_low_global(struct zone *zone)
{
	unsigned long active, inactive;

	active = zone_page_state(zone, NR_ACTIVE_ANON);
	inactive = zone_page_state(zone, NR_INACTIVE_ANON);

	/*
		非活跃匿名页数量*比例系数 < 活跃匿名页数量
		当zone内部managed_pages容量小于G时,inactive_ratio的值为1,大于则为根号下(10×gb)的取值
	*/
	if (inactive * zone->inactive_ratio /*1*/< active)
		return 1;

	return 0;
}
shrink_active_list函数在后面部分进行详细讲解。

如何评判一个zone是否到达平衡即其内部页面数量充足,能够进行页面的分配?即判断在分配2^order个页面后是否还满足高水位值+balance_gap。

复制代码
static bool zone_balanced(struct zone *zone, int order,unsigned long balance_gap, int classzone_idx)
{
	/*在分配2^order个页面下,是否满足水位值*/
	if (!zone_watermark_ok_safe(zone, order, high_wmark_pages(zone) +balance_gap/*高水位+balance_gap值*/, classzone_idx, 0))
		return false;

	/*
	判断指定内存区域(zone)是否适合执行内存压缩(compaction)操作
	*/
	if (IS_ENABLED(CONFIG_COMPACTION)/*开启内存规则*/ && order && compaction_suitable(zone,
				order, 0, classzone_idx) == COMPACT_SKIPPED)
		return false;

	return true;
}

include/linux/vmstat.h
bool zone_watermark_ok_safe(struct zone *z, unsigned int order,
			unsigned long mark, int classzone_idx, int alloc_flags)
{
	/*当前内存域zone中完全空闲的页面总数*/
	long free_pages = zone_page_state(z, NR_FREE_PAGES);

	if (z->percpu_drift_mark && free_pages < z->percpu_drift_mark)/*开启精确计算*/
		free_pages = zone_page_state_snapshot(z, NR_FREE_PAGES); /*将zone中各个CPU的空闲内存数量进行汇总计算*/

	/*判断水位值是否ok*/
	return __zone_watermark_ok(z, order, mark, classzone_idx, alloc_flags,
								free_pages);
}

static inline unsigned long zone_page_state_snapshot(struct zone *zone,enum zone_stat_item item)
{
	/*
		vm_stat[item]是全局基准值,记录所有CPU已同步的统计总和
		vm_stat_diff[item]是每个CPU本地未同步的增量
		所以该计算更精确,将单个CPU未同步的数据进行统计
	*/
	/*获取zone->vm_stat[]统计数据*/
	long x = atomic_long_read(&zone->vm_stat[item]);

#ifdef CONFIG_SMP
	int cpu;
	/*强制进行同步操作,将zone中各个CPU的内存统计数据进行汇总*/
	for_each_online_cpu(cpu)
		x += per_cpu_ptr(zone->pageset, cpu)->vm_stat_diff[item];

	if (x < 0)
		x = 0;
#endif
	return x;
}

判断zone内部的水位值情况,去除需要分配的2^order个页面后,剩余可用页面和调整后水位值之间的关系。
mm/page_alloc.c
bool zone_watermark_ok(struct zone *z, unsigned int order/*分配阶数*/, unsigned long mark,
		      int classzone_idx, int alloc_flags)
{
	return __zone_watermark_ok(z, order, mark, classzone_idx, alloc_flags,zone_page_state(z, NR_FREE_PAGES));
}

static bool __zone_watermark_ok(struct zone *z, unsigned int order,
			unsigned long mark, int classzone_idx, int alloc_flags,
			long free_pages)
{
	/* free_pages may go negative - that's OK */
	/*mark值为水位值,分配物理页面后剩余的物理页面和水位值之间的关系*/
	long min = mark;
	int o;
	long free_cma = 0;

	/*去除需要分配的物理页面*/
	free_pages -= (1 << order) - 1;

	/*当分配请求携带ALLOC_HIGH或ALLOC_HARDER标志时,内核会放宽水位检查(如 min减半),允许分配后剩余页略低于lowmem_reserve[]*/
	if (alloc_flags & ALLOC_HIGH) /*高优先级分配:水位要求减半,这样对水位的要就就降低,允许在不满足条件下也能优先分配*/
		min -= min / 2;
	if (alloc_flags & ALLOC_HARDER)
		min -= min / 4;
#ifdef CONFIG_CMA
	/* If allocation can't use CMA areas don't use free CMA pages */
	if (!(alloc_flags & ALLOC_CMA))
		free_cma = zone_page_state(z, NR_FREE_CMA_PAGES);
#endif

	/*free_pages < min +  z->lowmem_reserve[]的空间时拒绝*/
	if (free_pages - free_cma <= min + z->lowmem_reserve[classzone_idx])
		return false;

	for (o = 0; o < order; o++) {
		/* At the next order, this order's pages become unavailable */
		/*去除 zone free_area中比oder小的各个order中空闲物理页面,因为对于当前order而言,小于order的free_area是没法进行分配的,视为无效*/
		free_pages -= z->free_area[o].nr_free << o;

		/* Require fewer higher order pages to be free */
		min >>= 1; /*min的值同步减半,min /= 2*/

		if (free_pages <= min) /*去除需要分配的order个页面后剩余可用页面和min进行比较*/
			return false;
	}
	return true;
}

/*
	负责对单个内存区域(zone)执行回收操作,它根据水位线、内存碎片等因素,决定回收多少页面以及何时停止
*/
static bool kswapd_shrink_zone(struct zone *zone,
			       int classzone_idx,
			       struct scan_control *sc,
			       unsigned long *nr_attempted/*输出参数,用于累计本次回收尝试的页数*/)
{
	int testorder = sc->order;
	/*判断zone是否"足够平衡"的阈值*/
	unsigned long balance_gap;
	/*标识当前是否为低内存压力场景*/
	bool lowmem_pressure;

	/* Reclaim above the high watermark. */
	/*
	SWAP_CLUSTER_MAX在内核中默认定义为32,这是一个经过权衡的经验值,用于平衡I/O效率、CPU开销和系统响应性.
	设置回收目标,将本次回收的目标页数sc->nr_to_reclaim设置为"高水位线"和SWAP_CLUSTER_MAX(一次回收的页数簇)中的较大值。
	这确保了回收工作至少会进行一轮,以将空闲内存推高到高水位线以上.
	*/
	sc->nr_to_reclaim = max(SWAP_CLUSTER_MAX/*32*/, high_wmark_pages(zone)/*高水位值*/);
	printk("-----%s,sc->nr_to_reclaim:%x%x \n",__func__,sc->nr_to_reclaim);

	/*
	 * Kswapd reclaims only single pages with compaction enabled. Trying
	 * too hard to reclaim until contiguous free pages have become
	 * available can hurt performance by evicting too much useful data
	 * from memory. Do not reclaim more than needed for compaction.
	 */
	/*
		为内存规整优化,如果启用了内存规整(compaction)且当前是分配高阶连续内存(sc->order > 0),则检查该zone是否适合进行规整
		如果适合,testorder会被设为0,这意味着,在判断是否"平衡"时,将只要求zone有足够的单页空闲,而不是要求有order阶的连续空闲块,
		从而避免因过度回收而影响性能
	*/
	if (IS_ENABLED(CONFIG_COMPACTION) && sc->order &&
			compaction_suitable(zone, sc->order, 0, classzone_idx)
							!= COMPACT_SKIPPED)
		testorder = 0;

	/*
	 * We put equal pressure on every zone, unless one zone has way too
	 * many pages free already. The "too many pages" is defined as the
	 * high wmark plus a "gap" where the gap is either the low
	 * watermark or 1% of the zone, whichever is smaller.
	 */
	/*
		计算平衡阈值,balance_gap定义了一个"宽松"的平衡区间。
		一个zone的空闲页数只要高于high_wmark + balance_gap,就可以被认为是"足够平衡"的。
		这避免了在所有zone水位线都略低于high时,kswapd对每个zone都进行过度回收
	*/
	/*取低水位值和zone->managed_pages/100之间的较小者*/
	balance_gap = min(low_wmark_pages(zone)/*低水位值*/, DIV_ROUND_UP(
			zone->managed_pages, KSWAPD_ZONE_BALANCE_GAP_RATIO/*100*/));

	printk("-----%s,balance_gap:0x%x \n",__func__,balance_gap);
	/*
	 * If there is no low memory pressure or the zone is balanced then no
	 * reclaim is necessary
	 */
	/*
	 lowmem_pressure是一个特定于高端内存的特殊压力标志
	*/
	lowmem_pressure = (buffer_heads_over_limit && is_highmem(zone));
	/*
		判断是否平衡,如果当前没有特殊压力,并且zone_balanced()判断该zone在testorder阶和balance_gap阈值下是平衡的,
		则无需进一步回收,直接返回true
	*/
	if (!lowmem_pressure && zone_balanced(zone, testorder,balance_gap, classzone_idx))
		return true;

	/*
		执行实际回收,调用shrink_zone()函数,扫描并回收zone中的页面。
		第三个参数指示本次回收是否针对classzone_idx指定的最高优先级zone,这会影响kswapd后续的扫描策略
	*/
	shrink_zone(zone, sc, zone_idx(zone) == classzone_idx);

	/* Account for the number of pages attempted to reclaim */
	/*
		累计回收尝试量,将本次shrink_zone尝试回收的页数(sc->nr_to_reclaim)累加到输出参数*nr_attempted中。
		这个统计值用于上层balance_pgdat()判断是否需要提高回收优先级
	*/
	*nr_attempted += sc->nr_to_reclaim;

	/*
		回收工作结束后,清除ZONE_WRITEBACK标志。
		这表明最近一次扫描中遇到的"大量正在回写"的情况已得到缓解
	*/
	clear_bit(ZONE_WRITEBACK, &zone->flags);

	/*
	 * If a zone reaches its high watermark, consider it to be no longer
	 * congested. It's possible there are dirty pages backed by congested
	 * BDIs but as pressure is relieved, speculatively avoid congestion
	 * waits.
	 */
	/*
		如果zone已经恢复到平衡状态(zone_balanced判断通过),则清除ZONE_CONGESTED和ZONE_DIRTY标志
		这向系统表明,由I/O拥塞或大量脏页引起的回收压力已经解除,可以恢复正常的内存分配流程
	*/
	if (zone_reclaimable(zone) &&
	    zone_balanced(zone, testorder, 0, classzone_idx)) {
		clear_bit(ZONE_CONGESTED, &zone->flags);
		clear_bit(ZONE_DIRTY, &zone->flags);
	}

	/*
		函数的最终返回值表示本次回收工作的"努力程度"。
		如果实际扫描的页数sc->nr_scanned达到了目标sc->nr_to_reclaim,则返回true
	*/
	return sc->nr_scanned >= sc->nr_to_reclaim;
}
相关推荐
无忧.芙桃10 小时前
Linux系统编程(四):用户与权限管理
linux·运维·服务器
最强小杰11 小时前
某 OpenAI 兼容网关上的 `kimi-k3.1-pro`:Cline、Zed 接入与 SSE 排错示例
java·服务器·网络·ai
戊本菌13 小时前
进程(三)进程优先级:谁先上 CPU
linux·c语言·硬件架构
aningx14 小时前
Arch 系用 greetd 实现开机自动进 Plasma Wayland,注销自动回桌面
linux
张小姐的猫14 小时前
【基于 WebSocket 的多用户网页五子棋】—— 整合封装服务器模块设计实现2️⃣
服务器·websocket·网络协议
江无行者15 小时前
Linux 服务器 top 命令详解
linux
HMS工业网络15 小时前
工业远程访问的五项安全部署原则
运维·服务器·安全
嵌入式 Linux手记17 小时前
一块内存,三种解释:union 的真实用法
linux·c语言·驱动开发·嵌入式
星恒随风17 小时前
MySQL 从零入门(九):事务管理详解——ACID、COMMIT、ROLLBACK、SAVEPOINT 与四种隔离级别
linux·服务器·数据库·笔记·mysql
草莓熊Lotso18 小时前
【C++ 基于微服务的即时通讯系统】ElasticSearch 用户数据管理实现
linux·数据库·c++·elasticsearch·微服务·架构