Commit 25d00f68 authored by Lu Jialin's avatar Lu Jialin Committed by yanhaitao
Browse files

sched/psi: add more memory fine grained stall tracking in pressure.stat 

hulk inclusion
category: feature
bugzilla: https://gitee.com/openeuler/kernel/issues/I8QUNW



-------------------------------

Introcude more memory fine grianed stall tracking in pressure.stat, such
as global memory relcaim, memory compact, memory async cgroup reclaim
and swap.

Signed-off-by: default avatarLu Jialin <lujialin4@huawei.com>
parent 4a69b565

include/linux/psi_types.h

+24 −0
Original line number Diff line number Diff line
@@ -85,12 +85,28 @@ enum psi_aggregators { 
enum psi_stat_states {

	PSI_MEMCG_RECLAIM_SOME,

	PSI_MEMCG_RECLAIM_FULL,

	PSI_GLOBAL_RECLAIM_SOME,

	PSI_GLOBAL_RECLAIM_FULL,

	PSI_COMPACT_SOME,

	PSI_COMPACT_FULL,

	PSI_ASYNC_MEMCG_RECLAIM_SOME,

	PSI_ASYNC_MEMCG_RECLAIM_FULL,

	PSI_SWAP_SOME,

	PSI_SWAP_FULL,

	NR_PSI_STAT_STATES,

};



enum psi_stat_task_count {

	NR_MEMCG_RECLAIM,

	NR_MEMCG_RECLAIM_RUNNING,

	NR_GLOBAL_RECLAIM,

	NR_GLOBAL_RECLAIM_RUNNING,

	NR_COMPACT,

	NR_COMPACT_RUNNING,

	NR_ASYNC_MEMCG_RECLAIM,

	NR_ASYNC_MEMCG_RECLAIM_RUNNING,

	NR_SWAP,

	NR_SWAP_RUNNING,

	NR_PSI_STAT_TASK_COUNTS,

};

#endif /* CONFIG_PSI_FINE_GRAINED */
@@ -256,9 +272,17 @@ struct psi_group { }; 
 */

enum psi_memstall_type {

	PSI_MEMCG_RECLAIM = 1,

	PSI_GLOBAL_RECLAIM,

	PSI_COMPACT,

	PSI_ASYNC_MEMCG_RECLAIM,

	PSI_SWAP,

};

#else

#define PSI_MEMCG_RECLAIM		0

#define PSI_GLOBAL_RECLAIM		0

#define PSI_COMPACT			0

#define PSI_ASYNC_MEMCG_RECLAIM		0

#define PSI_SWAP			0

#endif /* CONFIG_PSI_FINE_GRAINED */



#endif /* _LINUX_PSI_TYPES_H */

kernel/sched/psi.c

+44 −0
Original line number Diff line number Diff line
@@ -349,6 +349,26 @@ static void record_stat_times(struct psi_group_cpu *groupc, u32 delta) 
		if (groupc->fine_grained_state_mask & (1 << PSI_MEMCG_RECLAIM_FULL))

			groupc->fine_grained_times[PSI_MEMCG_RECLAIM_FULL] += delta;

	}

	if (groupc->fine_grained_state_mask & (1 << PSI_GLOBAL_RECLAIM_SOME)) {

		groupc->fine_grained_times[PSI_GLOBAL_RECLAIM_SOME] += delta;

		if (groupc->fine_grained_state_mask & (1 << PSI_GLOBAL_RECLAIM_FULL))

			groupc->fine_grained_times[PSI_GLOBAL_RECLAIM_FULL] += delta;

	}

	if (groupc->fine_grained_state_mask & (1 << PSI_COMPACT_SOME)) {

		groupc->fine_grained_times[PSI_COMPACT_SOME] += delta;

		if (groupc->fine_grained_state_mask & (1 << PSI_COMPACT_FULL))

			groupc->fine_grained_times[PSI_COMPACT_FULL] += delta;

	}

	if (groupc->fine_grained_state_mask & (1 << PSI_ASYNC_MEMCG_RECLAIM_SOME)) {

		groupc->fine_grained_times[PSI_ASYNC_MEMCG_RECLAIM_SOME] += delta;

		if (groupc->fine_grained_state_mask & (1 << PSI_ASYNC_MEMCG_RECLAIM_FULL))

			groupc->fine_grained_times[PSI_ASYNC_MEMCG_RECLAIM_FULL] += delta;

	}

	if (groupc->fine_grained_state_mask & (1 << PSI_SWAP_SOME)) {

		groupc->fine_grained_times[PSI_SWAP_SOME] += delta;

		if (groupc->fine_grained_state_mask & (1 << PSI_SWAP_FULL))

			groupc->fine_grained_times[PSI_SWAP_FULL] += delta;

	}

}



static bool test_fine_grained_stat(unsigned int *stat_tasks,
@@ -361,6 +381,26 @@ static bool test_fine_grained_stat(unsigned int *stat_tasks, 
	case PSI_MEMCG_RECLAIM_FULL:

		return unlikely(stat_tasks[NR_MEMCG_RECLAIM] &&

		       nr_running == stat_tasks[NR_MEMCG_RECLAIM_RUNNING]);

	case PSI_GLOBAL_RECLAIM_SOME:

		return unlikely(stat_tasks[NR_GLOBAL_RECLAIM]);

	case PSI_GLOBAL_RECLAIM_FULL:

		return unlikely(stat_tasks[NR_GLOBAL_RECLAIM] &&

		       nr_running == stat_tasks[NR_GLOBAL_RECLAIM_RUNNING]);

	case PSI_COMPACT_SOME:

		return unlikely(stat_tasks[NR_COMPACT]);

	case PSI_COMPACT_FULL:

		return unlikely(stat_tasks[NR_COMPACT] &&

		       nr_running == stat_tasks[NR_COMPACT_RUNNING]);

	case PSI_ASYNC_MEMCG_RECLAIM_SOME:

		return unlikely(stat_tasks[NR_ASYNC_MEMCG_RECLAIM]);

	case PSI_ASYNC_MEMCG_RECLAIM_FULL:

		return unlikely(stat_tasks[NR_ASYNC_MEMCG_RECLAIM] &&

		      nr_running == stat_tasks[NR_ASYNC_MEMCG_RECLAIM_RUNNING]);

	case PSI_SWAP_SOME:

		return unlikely(stat_tasks[NR_SWAP]);

	case PSI_SWAP_FULL:

		return unlikely(stat_tasks[NR_SWAP] &&

		       nr_running == stat_tasks[NR_SWAP_RUNNING]);

	default:

		return false;

	}
@@ -1817,6 +1857,10 @@ static const struct proc_ops psi_cpu_proc_ops = { 
#ifdef CONFIG_PSI_FINE_GRAINED

static const char *const psi_stat_names[] = {

	"cgroup_memory_reclaim",

	"global_memory_reclaim",

	"compact",

	"cgroup_async_memory_reclaim",

	"swap",

};



int psi_stat_show(struct seq_file *m, struct psi_group *group)

mm/memcontrol.c

+1 −1
Original line number Diff line number Diff line
@@ -2459,7 +2459,7 @@ static void async_reclaim_high(struct mem_cgroup *memcg) 
		return;

	}



	pflags = 0;

	pflags = PSI_ASYNC_MEMCG_RECLAIM;

	psi_memstall_enter(&pflags);

	nr_pages = memcg_usage > safe_pages ? memcg_usage - safe_pages :

		   MEMCG_CHARGE_BATCH;

mm/page_alloc.c

+2 −2
Original line number Diff line number Diff line
@@ -3518,7 +3518,7 @@ __alloc_pages_direct_compact(gfp_t gfp_mask, unsigned int order, 
	if (!order)

		return NULL;



	pflags = 0;

	pflags = PSI_COMPACT;

	psi_memstall_enter(&pflags);

	delayacct_compact_start();

	noreclaim_flag = memalloc_noreclaim_save();
@@ -3788,7 +3788,7 @@ __alloc_pages_direct_reclaim(gfp_t gfp_mask, unsigned int order, 
	unsigned long pflags;

	bool drained = false;



	pflags = 0;

	pflags = PSI_GLOBAL_RECLAIM;

	psi_memstall_enter(&pflags);

	*did_some_progress = __perform_reclaim(gfp_mask, order, ac);

	if (unlikely(!(*did_some_progress)))

mm/page_io.c

+1 −1
Original line number Diff line number Diff line
@@ -509,7 +509,7 @@ void swap_readpage(struct page *page, bool synchronous, struct swap_iocb **plug) 
	 */

	if (workingset) {

		delayacct_thrashing_start(&in_thrashing);

		pflags = 0;

		pflags = PSI_SWAP;

		psi_memstall_enter(&pflags);

	}

	delayacct_swapin_start();