diff mbox series

[f2fs-dev,7/7] f2fs: add valid block ratio not to do excessive GC for one time GC

Message ID 20240829215242.3641502-7-daeho43@gmail.com (mailing list archive)
State Superseded
Headers show
Series [f2fs-dev,1/7] f2fs: make BG GC more aggressive for zoned devices | expand

Commit Message

Daeho Jeong Aug. 29, 2024, 9:52 p.m. UTC 
From: Daeho Jeong <daehojeong@google.com>

We need to introduce a valid block ratio threshold not to trigger
excessive GC for zoned deivces. The initial value of it is 95%. So, F2FS
will stop the thread from intiating GC for sections having valid blocks
exceeding the ratio.

Signed-off-by: Daeho Jeong <daehojeong@google.com>
---
 Documentation/ABI/testing/sysfs-fs-f2fs |  8 ++++++++
 fs/f2fs/f2fs.h                          |  2 +-
 fs/f2fs/gc.c                            | 15 +++++++++++----
 fs/f2fs/gc.h                            |  2 ++
 fs/f2fs/segment.c                       |  6 ++++--
 fs/f2fs/segment.h                       |  1 +
 fs/f2fs/sysfs.c                         |  2 ++
 7 files changed, 29 insertions(+), 7 deletions(-)

Comments

Chao Yu Sept. 9, 2024, 9:22 a.m. UTC | #1 
On 2024/8/30 5:52, Daeho Jeong wrote:
> From: Daeho Jeong <daehojeong@google.com>
> 
> We need to introduce a valid block ratio threshold not to trigger
> excessive GC for zoned deivces. The initial value of it is 95%. So, F2FS
> will stop the thread from intiating GC for sections having valid blocks
> exceeding the ratio.
> 
> Signed-off-by: Daeho Jeong <daehojeong@google.com>
> ---
>   Documentation/ABI/testing/sysfs-fs-f2fs |  8 ++++++++
>   fs/f2fs/f2fs.h                          |  2 +-
>   fs/f2fs/gc.c                            | 15 +++++++++++----
>   fs/f2fs/gc.h                            |  2 ++
>   fs/f2fs/segment.c                       |  6 ++++--
>   fs/f2fs/segment.h                       |  1 +
>   fs/f2fs/sysfs.c                         |  2 ++
>   7 files changed, 29 insertions(+), 7 deletions(-)
> 
> diff --git a/Documentation/ABI/testing/sysfs-fs-f2fs b/Documentation/ABI/testing/sysfs-fs-f2fs
> index 265baec879fd..2d3e42af0e63 100644
> --- a/Documentation/ABI/testing/sysfs-fs-f2fs
> +++ b/Documentation/ABI/testing/sysfs-fs-f2fs
> @@ -783,3 +783,11 @@ Contact:	"Daeho Jeong" <daehojeong@google.com>
>   Description:	If the percentage of free sections over total sections is under this
>   		number, F2FS boosts garbage collection for zoned devices through the
>   		background GC thread. the default number is "25".
> +
> +What:		/sys/fs/f2fs/<disk>/gc_valid_thresh_ratio
> +Date:		August 2024
> +Contact:	"Daeho Jeong" <daehojeong@google.com>
> +Description:	It controls the valid block ratio threshold not to trigger excessive GC
> +		for zoned deivces. The initial value of it is 95(%). F2FS will stop the
> +		background GC thread from intiating GC for sections having valid blocks
> +		exceeding the ratio.
> diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
> index ee1fafc65e95..8220b3189780 100644
> --- a/fs/f2fs/f2fs.h
> +++ b/fs/f2fs/f2fs.h
> @@ -3918,7 +3918,7 @@ void f2fs_destroy_garbage_collection_cache(void);
>   /* victim selection function for cleaning and SSR */
>   int f2fs_get_victim(struct f2fs_sb_info *sbi, unsigned int *result,
>   			int gc_type, int type, char alloc_mode,
> -			unsigned long long age);
> +			unsigned long long age, bool one_time);
>   
>   /*
>    * recovery.c
> diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
> index 6b79c43a57e3..feb80345aca3 100644
> --- a/fs/f2fs/gc.c
> +++ b/fs/f2fs/gc.c
> @@ -196,6 +196,7 @@ int f2fs_start_gc_thread(struct f2fs_sb_info *sbi)
>   		return -ENOMEM;
>   
>   	gc_th->urgent_sleep_time = DEF_GC_THREAD_URGENT_SLEEP_TIME;
> +	gc_th->valid_thresh_ratio = DEF_GC_THREAD_VALID_THRESH_RATIO;
>   
>   	if (f2fs_sb_has_blkzoned(sbi)) {
>   		gc_th->min_sleep_time = DEF_GC_THREAD_MIN_SLEEP_TIME_ZONED;
> @@ -396,6 +397,10 @@ static inline unsigned int get_gc_cost(struct f2fs_sb_info *sbi,
>   	if (p->alloc_mode == SSR)
>   		return get_seg_entry(sbi, segno)->ckpt_valid_blocks;
>   
> +	if (p->one_time_gc && (get_valid_blocks(sbi, segno, true) >=
> +		BLKS_PER_SEC(sbi) * sbi->gc_thread->valid_thresh_ratio / 100))

Use CAP_BLKS_PER_SEC() instead of BLKS_PER_SEC() ?

Thanks,

> +		return UINT_MAX;
> +
>   	/* alloc_mode == LFS */
>   	if (p->gc_mode == GC_GREEDY)
>   		return get_valid_blocks(sbi, segno, true);
> @@ -770,7 +775,7 @@ static int f2fs_gc_pinned_control(struct inode *inode, int gc_type,
>    */
>   int f2fs_get_victim(struct f2fs_sb_info *sbi, unsigned int *result,
>   			int gc_type, int type, char alloc_mode,
> -			unsigned long long age)
> +			unsigned long long age, bool one_time)
>   {
>   	struct dirty_seglist_info *dirty_i = DIRTY_I(sbi);
>   	struct sit_info *sm = SIT_I(sbi);
> @@ -787,6 +792,7 @@ int f2fs_get_victim(struct f2fs_sb_info *sbi, unsigned int *result,
>   	p.alloc_mode = alloc_mode;
>   	p.age = age;
>   	p.age_threshold = sbi->am.age_threshold;
> +	p.one_time_gc = one_time;
>   
>   retry:
>   	select_policy(sbi, gc_type, type, &p);
> @@ -1698,13 +1704,14 @@ static int gc_data_segment(struct f2fs_sb_info *sbi, struct f2fs_summary *sum,
>   }
>   
>   static int __get_victim(struct f2fs_sb_info *sbi, unsigned int *victim,
> -			int gc_type)
> +			int gc_type, bool one_time)
>   {
>   	struct sit_info *sit_i = SIT_I(sbi);
>   	int ret;
>   
>   	down_write(&sit_i->sentry_lock);
> -	ret = f2fs_get_victim(sbi, victim, gc_type, NO_CHECK_TYPE, LFS, 0);
> +	ret = f2fs_get_victim(sbi, victim, gc_type, NO_CHECK_TYPE,
> +			LFS, 0, one_time);
>   	up_write(&sit_i->sentry_lock);
>   	return ret;
>   }
> @@ -1908,7 +1915,7 @@ int f2fs_gc(struct f2fs_sb_info *sbi, struct f2fs_gc_control *gc_control)
>   		goto stop;
>   	}
>   retry:
> -	ret = __get_victim(sbi, &segno, gc_type);
> +	ret = __get_victim(sbi, &segno, gc_type, gc_control->one_time);
>   	if (ret) {
>   		/* allow to search victim from sections has pinned data */
>   		if (ret == -ENODATA && gc_type == FG_GC &&
> diff --git a/fs/f2fs/gc.h b/fs/f2fs/gc.h
> index e8195eb4ca6d..59872daf88ee 100644
> --- a/fs/f2fs/gc.h
> +++ b/fs/f2fs/gc.h
> @@ -25,6 +25,7 @@
>   #define DEF_GC_THREAD_CANDIDATE_RATIO		20	/* select 20% oldest sections as candidates */
>   #define DEF_GC_THREAD_MAX_CANDIDATE_COUNT	10	/* select at most 10 sections as candidates */
>   #define DEF_GC_THREAD_AGE_WEIGHT		60	/* age weight */
> +#define DEF_GC_THREAD_VALID_THRESH_RATIO	95	/* do not GC over 95% valid block ratio for one time GC */
>   #define DEFAULT_ACCURACY_CLASS			10000	/* accuracy class */
>   
>   #define LIMIT_INVALID_BLOCK	40 /* percentage over total user space */
> @@ -65,6 +66,7 @@ struct f2fs_gc_kthread {
>   	/* for gc control for zoned devices */
>   	unsigned int no_zoned_gc_percent;
>   	unsigned int boost_zoned_gc_percent;
> +	unsigned int valid_thresh_ratio;
>   };
>   
>   struct gc_inode_list {
> diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
> index 78c3198a6308..26f5abc62461 100644
> --- a/fs/f2fs/segment.c
> +++ b/fs/f2fs/segment.c
> @@ -3052,7 +3052,8 @@ static int get_ssr_segment(struct f2fs_sb_info *sbi, int type,
>   	sanity_check_seg_type(sbi, seg_type);
>   
>   	/* f2fs_need_SSR() already forces to do this */
> -	if (!f2fs_get_victim(sbi, &segno, BG_GC, seg_type, alloc_mode, age)) {
> +	if (!f2fs_get_victim(sbi, &segno, BG_GC, seg_type,
> +				alloc_mode, age, false)) {
>   		curseg->next_segno = segno;
>   		return 1;
>   	}
> @@ -3079,7 +3080,8 @@ static int get_ssr_segment(struct f2fs_sb_info *sbi, int type,
>   	for (; cnt-- > 0; reversed ? i-- : i++) {
>   		if (i == seg_type)
>   			continue;
> -		if (!f2fs_get_victim(sbi, &segno, BG_GC, i, alloc_mode, age)) {
> +		if (!f2fs_get_victim(sbi, &segno, BG_GC, i,
> +					alloc_mode, age, false)) {
>   			curseg->next_segno = segno;
>   			return 1;
>   		}
> diff --git a/fs/f2fs/segment.h b/fs/f2fs/segment.h
> index bfc01a521cb9..43db2d3e8c85 100644
> --- a/fs/f2fs/segment.h
> +++ b/fs/f2fs/segment.h
> @@ -188,6 +188,7 @@ struct victim_sel_policy {
>   	unsigned int min_segno;		/* segment # having min. cost */
>   	unsigned long long age;		/* mtime of GCed section*/
>   	unsigned long long age_threshold;/* age threshold */
> +	bool one_time_gc;		/* one time GC */
>   };
>   
>   struct seg_entry {
> diff --git a/fs/f2fs/sysfs.c b/fs/f2fs/sysfs.c
> index 647f6660f4df..d9d47c0698d1 100644
> --- a/fs/f2fs/sysfs.c
> +++ b/fs/f2fs/sysfs.c
> @@ -962,6 +962,7 @@ GC_THREAD_RW_ATTR(gc_max_sleep_time, max_sleep_time);
>   GC_THREAD_RW_ATTR(gc_no_gc_sleep_time, no_gc_sleep_time);
>   GC_THREAD_RW_ATTR(gc_no_zoned_gc_percent, no_zoned_gc_percent);
>   GC_THREAD_RW_ATTR(gc_boost_zoned_gc_percent, boost_zoned_gc_percent);
> +GC_THREAD_RW_ATTR(gc_valid_thresh_ratio, valid_thresh_ratio);
>   
>   /* SM_INFO ATTR */
>   SM_INFO_RW_ATTR(reclaim_segments, rec_prefree_segments);
> @@ -1121,6 +1122,7 @@ static struct attribute *f2fs_attrs[] = {
>   	ATTR_LIST(gc_no_gc_sleep_time),
>   	ATTR_LIST(gc_no_zoned_gc_percent),
>   	ATTR_LIST(gc_boost_zoned_gc_percent),
> +	ATTR_LIST(gc_valid_thresh_ratio),
>   	ATTR_LIST(gc_idle),
>   	ATTR_LIST(gc_urgent),
>   	ATTR_LIST(reclaim_segments),
diff mbox series

Patch

diff --git a/Documentation/ABI/testing/sysfs-fs-f2fs b/Documentation/ABI/testing/sysfs-fs-f2fs
index 265baec879fd..2d3e42af0e63 100644
--- a/Documentation/ABI/testing/sysfs-fs-f2fs
+++ b/Documentation/ABI/testing/sysfs-fs-f2fs
@@ -783,3 +783,11 @@  Contact:	"Daeho Jeong" <daehojeong@google.com>
 Description:	If the percentage of free sections over total sections is under this
 		number, F2FS boosts garbage collection for zoned devices through the
 		background GC thread. the default number is "25".
+
+What:		/sys/fs/f2fs/<disk>/gc_valid_thresh_ratio
+Date:		August 2024
+Contact:	"Daeho Jeong" <daehojeong@google.com>
+Description:	It controls the valid block ratio threshold not to trigger excessive GC
+		for zoned deivces. The initial value of it is 95(%). F2FS will stop the
+		background GC thread from intiating GC for sections having valid blocks
+		exceeding the ratio.
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index ee1fafc65e95..8220b3189780 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -3918,7 +3918,7 @@  void f2fs_destroy_garbage_collection_cache(void);
 /* victim selection function for cleaning and SSR */
 int f2fs_get_victim(struct f2fs_sb_info *sbi, unsigned int *result,
 			int gc_type, int type, char alloc_mode,
-			unsigned long long age);
+			unsigned long long age, bool one_time);
 
 /*
  * recovery.c
diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
index 6b79c43a57e3..feb80345aca3 100644
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -196,6 +196,7 @@  int f2fs_start_gc_thread(struct f2fs_sb_info *sbi)
 		return -ENOMEM;
 
 	gc_th->urgent_sleep_time = DEF_GC_THREAD_URGENT_SLEEP_TIME;
+	gc_th->valid_thresh_ratio = DEF_GC_THREAD_VALID_THRESH_RATIO;
 
 	if (f2fs_sb_has_blkzoned(sbi)) {
 		gc_th->min_sleep_time = DEF_GC_THREAD_MIN_SLEEP_TIME_ZONED;
@@ -396,6 +397,10 @@  static inline unsigned int get_gc_cost(struct f2fs_sb_info *sbi,
 	if (p->alloc_mode == SSR)
 		return get_seg_entry(sbi, segno)->ckpt_valid_blocks;
 
+	if (p->one_time_gc && (get_valid_blocks(sbi, segno, true) >=
+		BLKS_PER_SEC(sbi) * sbi->gc_thread->valid_thresh_ratio / 100))
+		return UINT_MAX;
+
 	/* alloc_mode == LFS */
 	if (p->gc_mode == GC_GREEDY)
 		return get_valid_blocks(sbi, segno, true);
@@ -770,7 +775,7 @@  static int f2fs_gc_pinned_control(struct inode *inode, int gc_type,
  */
 int f2fs_get_victim(struct f2fs_sb_info *sbi, unsigned int *result,
 			int gc_type, int type, char alloc_mode,
-			unsigned long long age)
+			unsigned long long age, bool one_time)
 {
 	struct dirty_seglist_info *dirty_i = DIRTY_I(sbi);
 	struct sit_info *sm = SIT_I(sbi);
@@ -787,6 +792,7 @@  int f2fs_get_victim(struct f2fs_sb_info *sbi, unsigned int *result,
 	p.alloc_mode = alloc_mode;
 	p.age = age;
 	p.age_threshold = sbi->am.age_threshold;
+	p.one_time_gc = one_time;
 
 retry:
 	select_policy(sbi, gc_type, type, &p);
@@ -1698,13 +1704,14 @@  static int gc_data_segment(struct f2fs_sb_info *sbi, struct f2fs_summary *sum,
 }
 
 static int __get_victim(struct f2fs_sb_info *sbi, unsigned int *victim,
-			int gc_type)
+			int gc_type, bool one_time)
 {
 	struct sit_info *sit_i = SIT_I(sbi);
 	int ret;
 
 	down_write(&sit_i->sentry_lock);
-	ret = f2fs_get_victim(sbi, victim, gc_type, NO_CHECK_TYPE, LFS, 0);
+	ret = f2fs_get_victim(sbi, victim, gc_type, NO_CHECK_TYPE,
+			LFS, 0, one_time);
 	up_write(&sit_i->sentry_lock);
 	return ret;
 }
@@ -1908,7 +1915,7 @@  int f2fs_gc(struct f2fs_sb_info *sbi, struct f2fs_gc_control *gc_control)
 		goto stop;
 	}
 retry:
-	ret = __get_victim(sbi, &segno, gc_type);
+	ret = __get_victim(sbi, &segno, gc_type, gc_control->one_time);
 	if (ret) {
 		/* allow to search victim from sections has pinned data */
 		if (ret == -ENODATA && gc_type == FG_GC &&
diff --git a/fs/f2fs/gc.h b/fs/f2fs/gc.h
index e8195eb4ca6d..59872daf88ee 100644
--- a/fs/f2fs/gc.h
+++ b/fs/f2fs/gc.h
@@ -25,6 +25,7 @@ 
 #define DEF_GC_THREAD_CANDIDATE_RATIO		20	/* select 20% oldest sections as candidates */
 #define DEF_GC_THREAD_MAX_CANDIDATE_COUNT	10	/* select at most 10 sections as candidates */
 #define DEF_GC_THREAD_AGE_WEIGHT		60	/* age weight */
+#define DEF_GC_THREAD_VALID_THRESH_RATIO	95	/* do not GC over 95% valid block ratio for one time GC */
 #define DEFAULT_ACCURACY_CLASS			10000	/* accuracy class */
 
 #define LIMIT_INVALID_BLOCK	40 /* percentage over total user space */
@@ -65,6 +66,7 @@  struct f2fs_gc_kthread {
 	/* for gc control for zoned devices */
 	unsigned int no_zoned_gc_percent;
 	unsigned int boost_zoned_gc_percent;
+	unsigned int valid_thresh_ratio;
 };
 
 struct gc_inode_list {
diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 78c3198a6308..26f5abc62461 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -3052,7 +3052,8 @@  static int get_ssr_segment(struct f2fs_sb_info *sbi, int type,
 	sanity_check_seg_type(sbi, seg_type);
 
 	/* f2fs_need_SSR() already forces to do this */
-	if (!f2fs_get_victim(sbi, &segno, BG_GC, seg_type, alloc_mode, age)) {
+	if (!f2fs_get_victim(sbi, &segno, BG_GC, seg_type,
+				alloc_mode, age, false)) {
 		curseg->next_segno = segno;
 		return 1;
 	}
@@ -3079,7 +3080,8 @@  static int get_ssr_segment(struct f2fs_sb_info *sbi, int type,
 	for (; cnt-- > 0; reversed ? i-- : i++) {
 		if (i == seg_type)
 			continue;
-		if (!f2fs_get_victim(sbi, &segno, BG_GC, i, alloc_mode, age)) {
+		if (!f2fs_get_victim(sbi, &segno, BG_GC, i,
+					alloc_mode, age, false)) {
 			curseg->next_segno = segno;
 			return 1;
 		}
diff --git a/fs/f2fs/segment.h b/fs/f2fs/segment.h
index bfc01a521cb9..43db2d3e8c85 100644
--- a/fs/f2fs/segment.h
+++ b/fs/f2fs/segment.h
@@ -188,6 +188,7 @@  struct victim_sel_policy {
 	unsigned int min_segno;		/* segment # having min. cost */
 	unsigned long long age;		/* mtime of GCed section*/
 	unsigned long long age_threshold;/* age threshold */
+	bool one_time_gc;		/* one time GC */
 };
 
 struct seg_entry {
diff --git a/fs/f2fs/sysfs.c b/fs/f2fs/sysfs.c
index 647f6660f4df..d9d47c0698d1 100644
--- a/fs/f2fs/sysfs.c
+++ b/fs/f2fs/sysfs.c
@@ -962,6 +962,7 @@  GC_THREAD_RW_ATTR(gc_max_sleep_time, max_sleep_time);
 GC_THREAD_RW_ATTR(gc_no_gc_sleep_time, no_gc_sleep_time);
 GC_THREAD_RW_ATTR(gc_no_zoned_gc_percent, no_zoned_gc_percent);
 GC_THREAD_RW_ATTR(gc_boost_zoned_gc_percent, boost_zoned_gc_percent);
+GC_THREAD_RW_ATTR(gc_valid_thresh_ratio, valid_thresh_ratio);
 
 /* SM_INFO ATTR */
 SM_INFO_RW_ATTR(reclaim_segments, rec_prefree_segments);
@@ -1121,6 +1122,7 @@  static struct attribute *f2fs_attrs[] = {
 	ATTR_LIST(gc_no_gc_sleep_time),
 	ATTR_LIST(gc_no_zoned_gc_percent),
 	ATTR_LIST(gc_boost_zoned_gc_percent),
+	ATTR_LIST(gc_valid_thresh_ratio),
 	ATTR_LIST(gc_idle),
 	ATTR_LIST(gc_urgent),
 	ATTR_LIST(reclaim_segments),