Commit eefab123 authored by Lu Jialin's avatar Lu Jialin
Browse files

PSI: add more memory fine grained stall tracking in pressure.stat 

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



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

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 0ccf285c

block/blk-cgroup.c

+1 −1
Original line number Diff line number Diff line
@@ -1689,7 +1689,7 @@ static void blkcg_scale_delay(struct blkcg_gq *blkg, u64 now) 
 */

static void blkcg_maybe_throttle_blkg(struct blkcg_gq *blkg, bool use_memdelay)

{

	unsigned long pflags;

	unsigned long pflags = 0;

	bool clamp;

	u64 now = ktime_to_ns(ktime_get());

	u64 exp;

block/blk-core.c

+1 −1
Original line number Diff line number Diff line
@@ -1116,7 +1116,7 @@ blk_qc_t submit_bio(struct bio *bio) 
	 */

	if (unlikely(bio_op(bio) == REQ_OP_READ &&

	    bio_flagged(bio, BIO_WORKINGSET))) {

		unsigned long pflags;

		unsigned long pflags = 0;

		blk_qc_t ret;



		psi_memstall_enter(&pflags);

include/linux/psi_types.h

+20 −0
Original line number Diff line number Diff line
@@ -236,12 +236,28 @@ struct psi_group { 
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,

};
@@ -284,6 +300,10 @@ struct psi_group { }; 
 */

enum psi_memstall_type {

	PSI_MEMCG_RECLAIM = 1,

	PSI_GLOBAL_RECLAIM,

	PSI_COMPACT,

	PSI_ASYNC_MEMCG_RECLAIM,

	PSI_SWAP,

};



#endif /* _LINUX_PSI_TYPES_H */

kernel/sched/psi.c

+44 −0
Original line number Diff line number Diff line
@@ -357,6 +357,26 @@ static void record_stat_times(struct psi_group_ext *psi_ext, int cpu) 
		if (ext_grpc->state_mask & (1 << PSI_MEMCG_RECLAIM_FULL))

			ext_grpc->times[PSI_MEMCG_RECLAIM_FULL] += delta;

	}

	if (ext_grpc->state_mask & (1 << PSI_GLOBAL_RECLAIM_SOME)) {

		ext_grpc->times[PSI_GLOBAL_RECLAIM_SOME] += delta;

		if (ext_grpc->state_mask & (1 << PSI_GLOBAL_RECLAIM_FULL))

			ext_grpc->times[PSI_GLOBAL_RECLAIM_FULL] += delta;

	}

	if (ext_grpc->state_mask & (1 << PSI_COMPACT_SOME)) {

		ext_grpc->times[PSI_COMPACT_SOME] += delta;

		if (ext_grpc->state_mask & (1 << PSI_COMPACT_FULL))

			ext_grpc->times[PSI_COMPACT_FULL] += delta;

	}

	if (ext_grpc->state_mask & (1 << PSI_ASYNC_MEMCG_RECLAIM_SOME)) {

		ext_grpc->times[PSI_ASYNC_MEMCG_RECLAIM_SOME] += delta;

		if (ext_grpc->state_mask & (1 << PSI_ASYNC_MEMCG_RECLAIM_FULL))

			ext_grpc->times[PSI_ASYNC_MEMCG_RECLAIM_FULL] += delta;

	}

	if (ext_grpc->state_mask & (1 << PSI_SWAP_SOME)) {

		ext_grpc->times[PSI_SWAP_SOME] += delta;

		if (ext_grpc->state_mask & (1 << PSI_SWAP_FULL))

			ext_grpc->times[PSI_SWAP_FULL] += delta;

	}

}



static bool test_fine_grained_stat(unsigned int *stat_tasks,
@@ -369,6 +389,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;

	}
@@ -1721,6 +1761,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/compaction.c

+1 −1
Original line number Diff line number Diff line
@@ -2852,7 +2852,7 @@ static int kcompactd(void *p) 
	pgdat->kcompactd_highest_zoneidx = pgdat->nr_zones - 1;



	while (!kthread_should_stop()) {

		unsigned long pflags;

		unsigned long pflags = 0;



		trace_mm_compaction_kcompactd_sleep(pgdat->node_id);

		if (wait_event_freezable_timeout(pgdat->kcompactd_wait,