Skip to contentSkip to conversation

f2fs: set 4KB discard granularity by default

PATCH In review Chao Yu 3 participants 19 messages Aug 10, 2018 – Sep 5, 2018 1 message not in the archive F2FS file system

lore
Share & tools
lore

Chao Yu

author
#0 lore raw

PATCH 1/2 f2fs: set 4KB discard granularity by default

Small granularity (size < 64K) fragmentation will cause f2fs suspending all pending discards, result in performance regression, so let's set 4KB discard granularity by default.

So that without fstrim, we also have the ability to avoid any performance regression caused by non-alignment mapping between fs and flash device.

---
 fs/f2fs/f2fs.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
fs/f2fs/f2fs.h +1 -1
index 58431b9bfd8f..273ffdaf4891 100644
@@ -248,7 +248,7 @@ struct discard_entry {
 };
 
 /* default discard granularity of inner discard thread, unit: block count */
-#define DEFAULT_DISCARD_GRANULARITY		16
+#define DEFAULT_DISCARD_GRANULARITY		1
 
 /* max discard pend list number */
 #define MAX_PLIST_NUM		512
Signature · 1 line
2.18.0.rc1
author
#1 lore raw

PATCH 2/2 f2fs: tune discard speed with storage usage rate

Previously, discard speed was fixed mostly, and in high usage rate device, we will speed up issuing discard, but it doesn't make sense that in a non-full filesystem, we still issue discard with slow speed.

Anyway, it comes out undiscarded block makes FTL GC be lower efficient and causing high lifetime overhead.

Let's tune discard speed as below:

a. adjust default issue interval:
original after
min_interval: 50ms 100ms
mid_interval: 500ms 1000ms
max_interval: 60000ms 10000ms

b. if last time we stop issuing discard due to IO interruption of user, let's reset all {min,mid,max}_interval to default one.

c. tune {min,mid,max}_interval with below calculation method:

base_interval = default_interval / 10;
total_interval = default_interval - base_interval; interval = base_interval + total_interval * (100 - dev_util) / 100;

For example:
min_interval (:100ms)
dev_util (%) interval (ms)
0 100
10 91
20 82
30 73
...
80 28
90 19
100 10

---
 fs/f2fs/f2fs.h    | 11 ++++----
 fs/f2fs/segment.c | 64 +++++++++++++++++++++++++++++++++++++----------
 fs/f2fs/segment.h |  9 +++++++
 fs/f2fs/super.c   |  2 +-
 4 files changed, 67 insertions(+), 19 deletions(-)
fs/f2fs/f2fs.h +6 -5
index 273ffdaf4891..a1dd2e1c3cb9 100644
@@ -185,10 +185,9 @@ enum {
 
 #define MAX_DISCARD_BLOCKS(sbi)		BLKS_PER_SEC(sbi)
 #define DEF_MAX_DISCARD_REQUEST		8	/* issue 8 discards per round */
-#define DEF_MIN_DISCARD_ISSUE_TIME	50	/* 50 ms, if exists */
-#define DEF_MID_DISCARD_ISSUE_TIME	500	/* 500 ms, if device busy */
-#define DEF_MAX_DISCARD_ISSUE_TIME	60000	/* 60 s, if no candidates */
-#define DEF_DISCARD_URGENT_UTIL		80	/* do more discard over 80% */
+#define DEF_MIN_DISCARD_ISSUE_TIME	100	/* 100 ms, if exists */
+#define DEF_MID_DISCARD_ISSUE_TIME	1000	/* 1000 ms, if device busy */
+#define DEF_MAX_DISCARD_ISSUE_TIME	10000	/* 10000 ms, if no candidates */
 #define DEF_CP_INTERVAL			60	/* 60 secs */
 #define DEF_IDLE_INTERVAL		5	/* 5 secs */
 
@@ -248,7 +247,8 @@ struct discard_entry {
 };
 
 /* default discard granularity of inner discard thread, unit: block count */
-#define DEFAULT_DISCARD_GRANULARITY		1
+#define MID_DISCARD_GRANULARITY			16
+#define MIN_DISCARD_GRANULARITY			1
 
 /* max discard pend list number */
 #define MAX_PLIST_NUM		512
@@ -330,6 +330,7 @@ struct discard_cmd_control {
 	atomic_t discard_cmd_cnt;		/* # of cached cmd count */
 	struct rb_root root;			/* root of discard rb-tree */
 	bool rbtree_check;			/* config for consistence check */
+	bool io_interrupted;			/* last state of io interrupted */
 };
 
 /* for the list of fsync inodes, used only during recovery */
fs/f2fs/segment.c +51 -13

116 lines not on this page · raw message

fs/f2fs/segment.h +9 -0
index 422b0ceb1eaa..63b4da72cd34 100644
@@ -616,6 +616,15 @@ static inline int utilization(struct f2fs_sb_info *sbi)
 					sbi->user_block_count);
 }
 
+static inline int dev_utilization(struct f2fs_sb_info *sbi)
+{
+	unsigned int dev_blks;
+
+	dev_blks = valid_user_blocks(sbi) + SM_I(sbi)->dcc_info->undiscard_blks;
+	return div_u64((u64)dev_blks * 100,
+			MAIN_SEGS(sbi) << sbi->log_blocks_per_seg);
+}
+
 /*
  * Sometimes f2fs may be better to drop out-of-place update policy.
  * And, users can control the policy through sysfs entries.
fs/f2fs/super.c +1 -1
index b055f2ea77c5..55ed76daad23 100644
@@ -2862,7 +2862,7 @@ static void f2fs_tuning_parameters(struct f2fs_sb_info *sbi)
 	/* adjust parameters according to the volume size */
 	if (sm_i->main_segments <= SMALL_VOLUME_SEGMENTS) {
 		F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;
-		sm_i->dcc_info->discard_granularity = 1;
+		sm_i->dcc_info->discard_granularity = MIN_DISCARD_GRANULARITY;
 		sm_i->ipu_policy = 1 << F2FS_IPU_FORCE;
 	}
 
Signature · 1 line
2.18.0.rc1
maintainer
#2 lore raw

Re: [PATCH 2/2] f2fs: tune discard speed with storage usage rate

Quoted 3 lines · Chao Yu

Previously, discard speed was fixed mostly, and in high usage rate device, we will speed up issuing discard, but it doesn't make sense that in a non-full filesystem, we still issue discard with slow speed.

Could you please elaborate the problem in more detail? The speed depends on how many candidates?

Thanks,

Quoted 240 lines

Anyway, it comes out undiscarded block makes FTL GC be lower efficient and causing high lifetime overhead.

Let's tune discard speed as below:

a. adjust default issue interval:
original after
min_interval: 50ms 100ms
mid_interval: 500ms 1000ms
max_interval: 60000ms 10000ms

b. if last time we stop issuing discard due to IO interruption of user, let's reset all {min,mid,max}_interval to default one.

c. tune {min,mid,max}_interval with below calculation method:

base_interval = default_interval / 10;
total_interval = default_interval - base_interval; interval = base_interval + total_interval * (100 - dev_util) / 100;

For example:
min_interval (:100ms)
dev_util (%) interval (ms)
0 100
10 91
20 82
30 73
...
80 28
90 19
100 10

---
 fs/f2fs/f2fs.h    | 11 ++++----
 fs/f2fs/segment.c | 64 +++++++++++++++++++++++++++++++++++++----------
 fs/f2fs/segment.h |  9 +++++++
 fs/f2fs/super.c   |  2 +-
 4 files changed, 67 insertions(+), 19 deletions(-)
fs/f2fs/f2fs.h +6 -5
index 273ffdaf4891..a1dd2e1c3cb9 100644
@@ -185,10 +185,9 @@ enum {
 
 #define MAX_DISCARD_BLOCKS(sbi)		BLKS_PER_SEC(sbi)
 #define DEF_MAX_DISCARD_REQUEST		8	/* issue 8 discards per round */
-#define DEF_MIN_DISCARD_ISSUE_TIME	50	/* 50 ms, if exists */
-#define DEF_MID_DISCARD_ISSUE_TIME	500	/* 500 ms, if device busy */
-#define DEF_MAX_DISCARD_ISSUE_TIME	60000	/* 60 s, if no candidates */
-#define DEF_DISCARD_URGENT_UTIL		80	/* do more discard over 80% */
+#define DEF_MIN_DISCARD_ISSUE_TIME	100	/* 100 ms, if exists */
+#define DEF_MID_DISCARD_ISSUE_TIME	1000	/* 1000 ms, if device busy */
+#define DEF_MAX_DISCARD_ISSUE_TIME	10000	/* 10000 ms, if no candidates */
 #define DEF_CP_INTERVAL			60	/* 60 secs */
 #define DEF_IDLE_INTERVAL		5	/* 5 secs */
 
@@ -248,7 +247,8 @@ struct discard_entry {
 };
 
 /* default discard granularity of inner discard thread, unit: block count */
-#define DEFAULT_DISCARD_GRANULARITY		1
+#define MID_DISCARD_GRANULARITY			16
+#define MIN_DISCARD_GRANULARITY			1
 
 /* max discard pend list number */
 #define MAX_PLIST_NUM		512
@@ -330,6 +330,7 @@ struct discard_cmd_control {
 	atomic_t discard_cmd_cnt;		/* # of cached cmd count */
 	struct rb_root root;			/* root of discard rb-tree */
 	bool rbtree_check;			/* config for consistence check */
+	bool io_interrupted;			/* last state of io interrupted */
 };
 
 /* for the list of fsync inodes, used only during recovery */
fs/f2fs/segment.c +51 -13
index 8b52e8dfb12f..9564aaf1f27b 100644
@@ -968,6 +968,44 @@ static void __check_sit_bitmap(struct f2fs_sb_info *sbi,
 #endif
 }
 
+static void __adjust_discard_speed(unsigned int *interval,
+				unsigned int def_interval, int dev_util)
+{
+	unsigned int base_interval, total_interval;
+
+	base_interval = def_interval / 10;
+	total_interval = def_interval - base_interval;
+
+	/*
+	 * if def_interval = 100, adjusted interval should be in range of
+	 * [10, 100].
+	 */
+	*interval = base_interval + total_interval * (100 - dev_util) / 100;
+}
+
+static void __tune_discard_policy(struct f2fs_sb_info *sbi,
+					struct discard_policy *dpolicy)
+{
+	struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
+	int dev_util;
+
+	if (dcc->io_interrupted) {
+		dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
+		dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
+		dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
+		return;
+	}
+
+	dev_util = dev_utilization(sbi);
+
+	__adjust_discard_speed(&dpolicy->min_interval,
+				DEF_MIN_DISCARD_ISSUE_TIME, dev_util);
+	__adjust_discard_speed(&dpolicy->mid_interval,
+				DEF_MID_DISCARD_ISSUE_TIME, dev_util);
+	__adjust_discard_speed(&dpolicy->max_interval,
+				DEF_MAX_DISCARD_ISSUE_TIME, dev_util);
+}
+
 static void __init_discard_policy(struct f2fs_sb_info *sbi,
 				struct discard_policy *dpolicy,
 				int discard_type, unsigned int granularity)
@@ -982,20 +1020,11 @@ static void __init_discard_policy(struct f2fs_sb_info *sbi,
 	dpolicy->io_aware_gran = MAX_PLIST_NUM;
 
 	if (discard_type == DPOLICY_BG) {
-		dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
-		dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
 		dpolicy->io_aware = true;
 		dpolicy->sync = false;
 		dpolicy->ordered = true;
-		if (utilization(sbi) > DEF_DISCARD_URGENT_UTIL) {
-			dpolicy->granularity = 1;
-			dpolicy->max_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		}
+		__tune_discard_policy(sbi, dpolicy);
 	} else if (discard_type == DPOLICY_FORCE) {
-		dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
-		dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
 		dpolicy->io_aware = false;
 	} else if (discard_type == DPOLICY_FSTRIM) {
 		dpolicy->io_aware = false;
@@ -1353,6 +1382,8 @@ static unsigned int __issue_discard_cmd_orderly(struct f2fs_sb_info *sbi,
 	if (!issued && io_interrupted)
 		issued = -1;
 
+	dcc->io_interrupted = io_interrupted;
+
 	return issued;
 }
 
@@ -1370,7 +1401,7 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi,
 		if (i + 1 < dpolicy->granularity)
 			break;
 
-		if (i < DEFAULT_DISCARD_GRANULARITY && dpolicy->ordered)
+		if (i < MID_DISCARD_GRANULARITY && dpolicy->ordered)
 			return __issue_discard_cmd_orderly(sbi, dpolicy);
 
 		pend_list = &dcc->pend_list[i];
@@ -1407,6 +1438,8 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi,
 	if (!issued && io_interrupted)
 		issued = -1;
 
+	dcc->io_interrupted = io_interrupted;
+
 	return issued;
 }
 
@@ -1576,7 +1609,11 @@ static int issue_discard_thread(void *data)
 	struct f2fs_sb_info *sbi = data;
 	struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
 	wait_queue_head_t *q = &dcc->discard_wait_queue;
-	struct discard_policy dpolicy;
+	struct discard_policy dpolicy = {
+		.min_interval = DEF_MIN_DISCARD_ISSUE_TIME,
+		.mid_interval = DEF_MID_DISCARD_ISSUE_TIME,
+		.max_interval = DEF_MAX_DISCARD_ISSUE_TIME,
+	};
 	unsigned int wait_ms = DEF_MIN_DISCARD_ISSUE_TIME;
 	int issued;
 
@@ -1929,7 +1966,7 @@ static int create_discard_cmd_control(struct f2fs_sb_info *sbi)
 	if (!dcc)
 		return -ENOMEM;
 
-	dcc->discard_granularity = DEFAULT_DISCARD_GRANULARITY;
+	dcc->discard_granularity = MIN_DISCARD_GRANULARITY;
 	INIT_LIST_HEAD(&dcc->entry_list);
 	for (i = 0; i < MAX_PLIST_NUM; i++)
 		INIT_LIST_HEAD(&dcc->pend_list[i]);
@@ -1945,6 +1982,7 @@ static int create_discard_cmd_control(struct f2fs_sb_info *sbi)
 	dcc->next_pos = 0;
 	dcc->root = RB_ROOT;
 	dcc->rbtree_check = false;
+	dcc->io_interrupted = false;
 
 	init_waitqueue_head(&dcc->discard_wait_queue);
 	SM_I(sbi)->dcc_info = dcc;
fs/f2fs/segment.h +9 -0
index 422b0ceb1eaa..63b4da72cd34 100644
@@ -616,6 +616,15 @@ static inline int utilization(struct f2fs_sb_info *sbi)
 					sbi->user_block_count);
 }
 
+static inline int dev_utilization(struct f2fs_sb_info *sbi)
+{
+	unsigned int dev_blks;
+
+	dev_blks = valid_user_blocks(sbi) + SM_I(sbi)->dcc_info->undiscard_blks;
+	return div_u64((u64)dev_blks * 100,
+			MAIN_SEGS(sbi) << sbi->log_blocks_per_seg);
+}
+
 /*
  * Sometimes f2fs may be better to drop out-of-place update policy.
  * And, users can control the policy through sysfs entries.
fs/f2fs/super.c +1 -1
index b055f2ea77c5..55ed76daad23 100644
@@ -2862,7 +2862,7 @@ static void f2fs_tuning_parameters(struct f2fs_sb_info *sbi)
 	/* adjust parameters according to the volume size */
 	if (sm_i->main_segments <= SMALL_VOLUME_SEGMENTS) {
 		F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;
-		sm_i->dcc_info->discard_granularity = 1;
+		sm_i->dcc_info->discard_granularity = MIN_DISCARD_GRANULARITY;
 		sm_i->ipu_policy = 1 << F2FS_IPU_FORCE;
 	}
 
Signature · 1 line
2.18.0.rc1
author
#3 lore raw

Re: [PATCH 2/2] f2fs: tune discard speed with storage usage rate

Quoted 7 lines · Jaegeuk Kim
Quoted 3 lines · Chao Yu

Previously, discard speed was fixed mostly, and in high usage rate device, we will speed up issuing discard, but it doesn't make sense that in a non-full filesystem, we still issue discard with slow speed.

Could you please elaborate the problem in more detail? The speed depends on how many candidates?

undiscard blocks are all 4k granularity.
a) utility: filesystem: 20% + undiscard blocks: 20% = flash storage: 40%
b) utility: filesystem: 40% + undiscard blocks: 25% = flash storage: 65%
c) utility: filesystem: 60% + undiscard blocks: 30% = flash storage: 100%

1. for case c), we need to speed up issuing discard based on utilization of "filesystem + undiscard" instead of just utilization of filesystem.

- if (utilization(sbi) > DEF_DISCARD_URGENT_UTIL) {
- dpolicy->granularity = 1;
- dpolicy->max_interval = DEF_MIN_DISCARD_ISSUE_TIME;
- }

2. If free space in storage touches therein threshold, performance will be very sensitive. In low-end storage, with high usage in space, even free space is reduced by 1%, performance will decrease a lot.

IMO, in above cases, we'd better to issue discard with high speed for c), middle speed for b), and low speed for a).

How do you think?

Thanks,

Quoted 246 lines

Thanks,

Quoted 240 lines

Anyway, it comes out undiscarded block makes FTL GC be lower efficient and causing high lifetime overhead.

Let's tune discard speed as below:

a. adjust default issue interval:
original after
min_interval: 50ms 100ms
mid_interval: 500ms 1000ms
max_interval: 60000ms 10000ms

b. if last time we stop issuing discard due to IO interruption of user, let's reset all {min,mid,max}_interval to default one.

c. tune {min,mid,max}_interval with below calculation method:

base_interval = default_interval / 10;
total_interval = default_interval - base_interval; interval = base_interval + total_interval * (100 - dev_util) / 100;

For example:
min_interval (:100ms)
dev_util (%) interval (ms)
0 100
10 91
20 82
30 73
...
80 28
90 19
100 10

---
 fs/f2fs/f2fs.h    | 11 ++++----
 fs/f2fs/segment.c | 64 +++++++++++++++++++++++++++++++++++++----------
 fs/f2fs/segment.h |  9 +++++++
 fs/f2fs/super.c   |  2 +-
 4 files changed, 67 insertions(+), 19 deletions(-)
fs/f2fs/f2fs.h +6 -5
index 273ffdaf4891..a1dd2e1c3cb9 100644
@@ -185,10 +185,9 @@ enum {
 
 #define MAX_DISCARD_BLOCKS(sbi)		BLKS_PER_SEC(sbi)
 #define DEF_MAX_DISCARD_REQUEST		8	/* issue 8 discards per round */
-#define DEF_MIN_DISCARD_ISSUE_TIME	50	/* 50 ms, if exists */
-#define DEF_MID_DISCARD_ISSUE_TIME	500	/* 500 ms, if device busy */
-#define DEF_MAX_DISCARD_ISSUE_TIME	60000	/* 60 s, if no candidates */
-#define DEF_DISCARD_URGENT_UTIL		80	/* do more discard over 80% */
+#define DEF_MIN_DISCARD_ISSUE_TIME	100	/* 100 ms, if exists */
+#define DEF_MID_DISCARD_ISSUE_TIME	1000	/* 1000 ms, if device busy */
+#define DEF_MAX_DISCARD_ISSUE_TIME	10000	/* 10000 ms, if no candidates */
 #define DEF_CP_INTERVAL			60	/* 60 secs */
 #define DEF_IDLE_INTERVAL		5	/* 5 secs */
 
@@ -248,7 +247,8 @@ struct discard_entry {
 };
 
 /* default discard granularity of inner discard thread, unit: block count */
-#define DEFAULT_DISCARD_GRANULARITY		1
+#define MID_DISCARD_GRANULARITY			16
+#define MIN_DISCARD_GRANULARITY			1
 
 /* max discard pend list number */
 #define MAX_PLIST_NUM		512
@@ -330,6 +330,7 @@ struct discard_cmd_control {
 	atomic_t discard_cmd_cnt;		/* # of cached cmd count */
 	struct rb_root root;			/* root of discard rb-tree */
 	bool rbtree_check;			/* config for consistence check */
+	bool io_interrupted;			/* last state of io interrupted */
 };
 
 /* for the list of fsync inodes, used only during recovery */
fs/f2fs/segment.c +51 -13
index 8b52e8dfb12f..9564aaf1f27b 100644
@@ -968,6 +968,44 @@ static void __check_sit_bitmap(struct f2fs_sb_info *sbi,
 #endif
 }
 
+static void __adjust_discard_speed(unsigned int *interval,
+				unsigned int def_interval, int dev_util)
+{
+	unsigned int base_interval, total_interval;
+
+	base_interval = def_interval / 10;
+	total_interval = def_interval - base_interval;
+
+	/*
+	 * if def_interval = 100, adjusted interval should be in range of
+	 * [10, 100].
+	 */
+	*interval = base_interval + total_interval * (100 - dev_util) / 100;
+}
+
+static void __tune_discard_policy(struct f2fs_sb_info *sbi,
+					struct discard_policy *dpolicy)
+{
+	struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
+	int dev_util;
+
+	if (dcc->io_interrupted) {
+		dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
+		dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
+		dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
+		return;
+	}
+
+	dev_util = dev_utilization(sbi);
+
+	__adjust_discard_speed(&dpolicy->min_interval,
+				DEF_MIN_DISCARD_ISSUE_TIME, dev_util);
+	__adjust_discard_speed(&dpolicy->mid_interval,
+				DEF_MID_DISCARD_ISSUE_TIME, dev_util);
+	__adjust_discard_speed(&dpolicy->max_interval,
+				DEF_MAX_DISCARD_ISSUE_TIME, dev_util);
+}
+
 static void __init_discard_policy(struct f2fs_sb_info *sbi,
 				struct discard_policy *dpolicy,
 				int discard_type, unsigned int granularity)
@@ -982,20 +1020,11 @@ static void __init_discard_policy(struct f2fs_sb_info *sbi,
 	dpolicy->io_aware_gran = MAX_PLIST_NUM;
 
 	if (discard_type == DPOLICY_BG) {
-		dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
-		dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
 		dpolicy->io_aware = true;
 		dpolicy->sync = false;
 		dpolicy->ordered = true;
-		if (utilization(sbi) > DEF_DISCARD_URGENT_UTIL) {
-			dpolicy->granularity = 1;
-			dpolicy->max_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		}
+		__tune_discard_policy(sbi, dpolicy);
 	} else if (discard_type == DPOLICY_FORCE) {
-		dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
-		dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
 		dpolicy->io_aware = false;
 	} else if (discard_type == DPOLICY_FSTRIM) {
 		dpolicy->io_aware = false;
@@ -1353,6 +1382,8 @@ static unsigned int __issue_discard_cmd_orderly(struct f2fs_sb_info *sbi,
 	if (!issued && io_interrupted)
 		issued = -1;
 
+	dcc->io_interrupted = io_interrupted;
+
 	return issued;
 }
 
@@ -1370,7 +1401,7 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi,
 		if (i + 1 < dpolicy->granularity)
 			break;
 
-		if (i < DEFAULT_DISCARD_GRANULARITY && dpolicy->ordered)
+		if (i < MID_DISCARD_GRANULARITY && dpolicy->ordered)
 			return __issue_discard_cmd_orderly(sbi, dpolicy);
 
 		pend_list = &dcc->pend_list[i];
@@ -1407,6 +1438,8 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi,
 	if (!issued && io_interrupted)
 		issued = -1;
 
+	dcc->io_interrupted = io_interrupted;
+
 	return issued;
 }
 
@@ -1576,7 +1609,11 @@ static int issue_discard_thread(void *data)
 	struct f2fs_sb_info *sbi = data;
 	struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
 	wait_queue_head_t *q = &dcc->discard_wait_queue;
-	struct discard_policy dpolicy;
+	struct discard_policy dpolicy = {
+		.min_interval = DEF_MIN_DISCARD_ISSUE_TIME,
+		.mid_interval = DEF_MID_DISCARD_ISSUE_TIME,
+		.max_interval = DEF_MAX_DISCARD_ISSUE_TIME,
+	};
 	unsigned int wait_ms = DEF_MIN_DISCARD_ISSUE_TIME;
 	int issued;
 
@@ -1929,7 +1966,7 @@ static int create_discard_cmd_control(struct f2fs_sb_info *sbi)
 	if (!dcc)
 		return -ENOMEM;
 
-	dcc->discard_granularity = DEFAULT_DISCARD_GRANULARITY;
+	dcc->discard_granularity = MIN_DISCARD_GRANULARITY;
 	INIT_LIST_HEAD(&dcc->entry_list);
 	for (i = 0; i < MAX_PLIST_NUM; i++)
 		INIT_LIST_HEAD(&dcc->pend_list[i]);
@@ -1945,6 +1982,7 @@ static int create_discard_cmd_control(struct f2fs_sb_info *sbi)
 	dcc->next_pos = 0;
 	dcc->root = RB_ROOT;
 	dcc->rbtree_check = false;
+	dcc->io_interrupted = false;
 
 	init_waitqueue_head(&dcc->discard_wait_queue);
 	SM_I(sbi)->dcc_info = dcc;
fs/f2fs/segment.h +9 -0
index 422b0ceb1eaa..63b4da72cd34 100644
@@ -616,6 +616,15 @@ static inline int utilization(struct f2fs_sb_info *sbi)
 					sbi->user_block_count);
 }
 
+static inline int dev_utilization(struct f2fs_sb_info *sbi)
+{
+	unsigned int dev_blks;
+
+	dev_blks = valid_user_blocks(sbi) + SM_I(sbi)->dcc_info->undiscard_blks;
+	return div_u64((u64)dev_blks * 100,
+			MAIN_SEGS(sbi) << sbi->log_blocks_per_seg);
+}
+
 /*
  * Sometimes f2fs may be better to drop out-of-place update policy.
  * And, users can control the policy through sysfs entries.
fs/f2fs/super.c +1 -1
index b055f2ea77c5..55ed76daad23 100644
@@ -2862,7 +2862,7 @@ static void f2fs_tuning_parameters(struct f2fs_sb_info *sbi)
 	/* adjust parameters according to the volume size */
 	if (sm_i->main_segments <= SMALL_VOLUME_SEGMENTS) {
 		F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;
-		sm_i->dcc_info->discard_granularity = 1;
+		sm_i->dcc_info->discard_granularity = MIN_DISCARD_GRANULARITY;
 		sm_i->ipu_policy = 1 << F2FS_IPU_FORCE;
 	}
 
Signature · 1 line
2.18.0.rc1

.

maintainer
#4 lore raw

Re: [PATCH 2/2] f2fs: tune discard speed with storage usage rate

Quoted 23 lines · Chao Yu
Quoted 7 lines · Jaegeuk Kim
Quoted 3 lines · Chao Yu

Previously, discard speed was fixed mostly, and in high usage rate device, we will speed up issuing discard, but it doesn't make sense that in a non-full filesystem, we still issue discard with slow speed.

Could you please elaborate the problem in more detail? The speed depends on how many candidates?

undiscard blocks are all 4k granularity.
a) utility: filesystem: 20% + undiscard blocks: 20% = flash storage: 40%
b) utility: filesystem: 40% + undiscard blocks: 25% = flash storage: 65%
c) utility: filesystem: 60% + undiscard blocks: 30% = flash storage: 100%

1. for case c), we need to speed up issuing discard based on utilization of "filesystem + undiscard" instead of just utilization of filesystem.

fs/f2fs/segment.c +0 -4
-		if (utilization(sbi) > DEF_DISCARD_URGENT_UTIL) {
-			dpolicy->granularity = 1;
-			dpolicy->max_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		}
Quoted 3 lines

2. If free space in storage touches therein threshold, performance will be very sensitive. In low-end storage, with high usage in space, even free space is reduced by 1%, performance will decrease a lot.

So, we may need to distinguish low-end vs. high-end storage. In high-end case, it'd be better to avoid IO contention, while low-end device wants to get more discard commands as much as possible. So, how about adding an option for this as a tunable point?

Quoted 254 lines

IMO, in above cases, we'd better to issue discard with high speed for c), middle speed for b), and low speed for a).

How do you think?

Thanks,

Quoted 246 lines

Thanks,

Quoted 240 lines

Anyway, it comes out undiscarded block makes FTL GC be lower efficient and causing high lifetime overhead.

Let's tune discard speed as below:

a. adjust default issue interval:
original after
min_interval: 50ms 100ms
mid_interval: 500ms 1000ms
max_interval: 60000ms 10000ms

b. if last time we stop issuing discard due to IO interruption of user, let's reset all {min,mid,max}_interval to default one.

c. tune {min,mid,max}_interval with below calculation method:

base_interval = default_interval / 10;
total_interval = default_interval - base_interval; interval = base_interval + total_interval * (100 - dev_util) / 100;

For example:
min_interval (:100ms)
dev_util (%) interval (ms)
0 100
10 91
20 82
30 73
...
80 28
90 19
100 10

---
 fs/f2fs/f2fs.h    | 11 ++++----
 fs/f2fs/segment.c | 64 +++++++++++++++++++++++++++++++++++++----------
 fs/f2fs/segment.h |  9 +++++++
 fs/f2fs/super.c   |  2 +-
 4 files changed, 67 insertions(+), 19 deletions(-)
fs/f2fs/f2fs.h +6 -5
index 273ffdaf4891..a1dd2e1c3cb9 100644
@@ -185,10 +185,9 @@ enum {
 
 #define MAX_DISCARD_BLOCKS(sbi)		BLKS_PER_SEC(sbi)
 #define DEF_MAX_DISCARD_REQUEST		8	/* issue 8 discards per round */
-#define DEF_MIN_DISCARD_ISSUE_TIME	50	/* 50 ms, if exists */
-#define DEF_MID_DISCARD_ISSUE_TIME	500	/* 500 ms, if device busy */
-#define DEF_MAX_DISCARD_ISSUE_TIME	60000	/* 60 s, if no candidates */
-#define DEF_DISCARD_URGENT_UTIL		80	/* do more discard over 80% */
+#define DEF_MIN_DISCARD_ISSUE_TIME	100	/* 100 ms, if exists */
+#define DEF_MID_DISCARD_ISSUE_TIME	1000	/* 1000 ms, if device busy */
+#define DEF_MAX_DISCARD_ISSUE_TIME	10000	/* 10000 ms, if no candidates */
 #define DEF_CP_INTERVAL			60	/* 60 secs */
 #define DEF_IDLE_INTERVAL		5	/* 5 secs */
 
@@ -248,7 +247,8 @@ struct discard_entry {
 };
 
 /* default discard granularity of inner discard thread, unit: block count */
-#define DEFAULT_DISCARD_GRANULARITY		1
+#define MID_DISCARD_GRANULARITY			16
+#define MIN_DISCARD_GRANULARITY			1
 
 /* max discard pend list number */
 #define MAX_PLIST_NUM		512
@@ -330,6 +330,7 @@ struct discard_cmd_control {
 	atomic_t discard_cmd_cnt;		/* # of cached cmd count */
 	struct rb_root root;			/* root of discard rb-tree */
 	bool rbtree_check;			/* config for consistence check */
+	bool io_interrupted;			/* last state of io interrupted */
 };
 
 /* for the list of fsync inodes, used only during recovery */
fs/f2fs/segment.c +51 -13
index 8b52e8dfb12f..9564aaf1f27b 100644
@@ -968,6 +968,44 @@ static void __check_sit_bitmap(struct f2fs_sb_info *sbi,
 #endif
 }
 
+static void __adjust_discard_speed(unsigned int *interval,
+				unsigned int def_interval, int dev_util)
+{
+	unsigned int base_interval, total_interval;
+
+	base_interval = def_interval / 10;
+	total_interval = def_interval - base_interval;
+
+	/*
+	 * if def_interval = 100, adjusted interval should be in range of
+	 * [10, 100].
+	 */
+	*interval = base_interval + total_interval * (100 - dev_util) / 100;
+}
+
+static void __tune_discard_policy(struct f2fs_sb_info *sbi,
+					struct discard_policy *dpolicy)
+{
+	struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
+	int dev_util;
+
+	if (dcc->io_interrupted) {
+		dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
+		dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
+		dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
+		return;
+	}
+
+	dev_util = dev_utilization(sbi);
+
+	__adjust_discard_speed(&dpolicy->min_interval,
+				DEF_MIN_DISCARD_ISSUE_TIME, dev_util);
+	__adjust_discard_speed(&dpolicy->mid_interval,
+				DEF_MID_DISCARD_ISSUE_TIME, dev_util);
+	__adjust_discard_speed(&dpolicy->max_interval,
+				DEF_MAX_DISCARD_ISSUE_TIME, dev_util);
+}
+
 static void __init_discard_policy(struct f2fs_sb_info *sbi,
 				struct discard_policy *dpolicy,
 				int discard_type, unsigned int granularity)
@@ -982,20 +1020,11 @@ static void __init_discard_policy(struct f2fs_sb_info *sbi,
 	dpolicy->io_aware_gran = MAX_PLIST_NUM;
 
 	if (discard_type == DPOLICY_BG) {
-		dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
-		dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
 		dpolicy->io_aware = true;
 		dpolicy->sync = false;
 		dpolicy->ordered = true;
-		if (utilization(sbi) > DEF_DISCARD_URGENT_UTIL) {
-			dpolicy->granularity = 1;
-			dpolicy->max_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		}
+		__tune_discard_policy(sbi, dpolicy);
 	} else if (discard_type == DPOLICY_FORCE) {
-		dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
-		dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
 		dpolicy->io_aware = false;
 	} else if (discard_type == DPOLICY_FSTRIM) {
 		dpolicy->io_aware = false;
@@ -1353,6 +1382,8 @@ static unsigned int __issue_discard_cmd_orderly(struct f2fs_sb_info *sbi,
 	if (!issued && io_interrupted)
 		issued = -1;
 
+	dcc->io_interrupted = io_interrupted;
+
 	return issued;
 }
 
@@ -1370,7 +1401,7 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi,
 		if (i + 1 < dpolicy->granularity)
 			break;
 
-		if (i < DEFAULT_DISCARD_GRANULARITY && dpolicy->ordered)
+		if (i < MID_DISCARD_GRANULARITY && dpolicy->ordered)
 			return __issue_discard_cmd_orderly(sbi, dpolicy);
 
 		pend_list = &dcc->pend_list[i];
@@ -1407,6 +1438,8 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi,
 	if (!issued && io_interrupted)
 		issued = -1;
 
+	dcc->io_interrupted = io_interrupted;
+
 	return issued;
 }
 
@@ -1576,7 +1609,11 @@ static int issue_discard_thread(void *data)
 	struct f2fs_sb_info *sbi = data;
 	struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
 	wait_queue_head_t *q = &dcc->discard_wait_queue;
-	struct discard_policy dpolicy;
+	struct discard_policy dpolicy = {
+		.min_interval = DEF_MIN_DISCARD_ISSUE_TIME,
+		.mid_interval = DEF_MID_DISCARD_ISSUE_TIME,
+		.max_interval = DEF_MAX_DISCARD_ISSUE_TIME,
+	};
 	unsigned int wait_ms = DEF_MIN_DISCARD_ISSUE_TIME;
 	int issued;
 
@@ -1929,7 +1966,7 @@ static int create_discard_cmd_control(struct f2fs_sb_info *sbi)
 	if (!dcc)
 		return -ENOMEM;
 
-	dcc->discard_granularity = DEFAULT_DISCARD_GRANULARITY;
+	dcc->discard_granularity = MIN_DISCARD_GRANULARITY;
 	INIT_LIST_HEAD(&dcc->entry_list);
 	for (i = 0; i < MAX_PLIST_NUM; i++)
 		INIT_LIST_HEAD(&dcc->pend_list[i]);
@@ -1945,6 +1982,7 @@ static int create_discard_cmd_control(struct f2fs_sb_info *sbi)
 	dcc->next_pos = 0;
 	dcc->root = RB_ROOT;
 	dcc->rbtree_check = false;
+	dcc->io_interrupted = false;
 
 	init_waitqueue_head(&dcc->discard_wait_queue);
 	SM_I(sbi)->dcc_info = dcc;
fs/f2fs/segment.h +9 -0
index 422b0ceb1eaa..63b4da72cd34 100644
@@ -616,6 +616,15 @@ static inline int utilization(struct f2fs_sb_info *sbi)
 					sbi->user_block_count);
 }
 
+static inline int dev_utilization(struct f2fs_sb_info *sbi)
+{
+	unsigned int dev_blks;
+
+	dev_blks = valid_user_blocks(sbi) + SM_I(sbi)->dcc_info->undiscard_blks;
+	return div_u64((u64)dev_blks * 100,
+			MAIN_SEGS(sbi) << sbi->log_blocks_per_seg);
+}
+
 /*
  * Sometimes f2fs may be better to drop out-of-place update policy.
  * And, users can control the policy through sysfs entries.
fs/f2fs/super.c +1 -1
index b055f2ea77c5..55ed76daad23 100644
@@ -2862,7 +2862,7 @@ static void f2fs_tuning_parameters(struct f2fs_sb_info *sbi)
 	/* adjust parameters according to the volume size */
 	if (sm_i->main_segments <= SMALL_VOLUME_SEGMENTS) {
 		F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;
-		sm_i->dcc_info->discard_granularity = 1;
+		sm_i->dcc_info->discard_granularity = MIN_DISCARD_GRANULARITY;
 		sm_i->ipu_policy = 1 << F2FS_IPU_FORCE;
 	}
 
Signature · 1 line
2.18.0.rc1

.

author
#5 lore raw

Re: [PATCH 2/2] f2fs: tune discard speed with storage usage rate

Quoted 24 lines · Jaegeuk Kim
Quoted 23 lines · Chao Yu
Quoted 7 lines · Jaegeuk Kim
Quoted 3 lines · Chao Yu

Previously, discard speed was fixed mostly, and in high usage rate device, we will speed up issuing discard, but it doesn't make sense that in a non-full filesystem, we still issue discard with slow speed.

Could you please elaborate the problem in more detail? The speed depends on how many candidates?

undiscard blocks are all 4k granularity.
a) utility: filesystem: 20% + undiscard blocks: 20% = flash storage: 40%
b) utility: filesystem: 40% + undiscard blocks: 25% = flash storage: 65%
c) utility: filesystem: 60% + undiscard blocks: 30% = flash storage: 100%

1. for case c), we need to speed up issuing discard based on utilization of "filesystem + undiscard" instead of just utilization of filesystem.

fs/f2fs/segment.c +0 -4
-		if (utilization(sbi) > DEF_DISCARD_URGENT_UTIL) {
-			dpolicy->granularity = 1;
-			dpolicy->max_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		}
Quoted 8 lines
Quoted 3 lines

2. If free space in storage touches therein threshold, performance will be very sensitive. In low-end storage, with high usage in space, even free space is reduced by 1%, performance will decrease a lot.

So, we may need to distinguish low-end vs. high-end storage. In high-end case, it'd be better to avoid IO contention, while low-end device wants to get more discard commands as much as possible. So, how about adding an option for this as a tunable point?

Agreed, how about adding a sysfs entry discard_tunning:
1: enabled, use 4k granularity, self-adapted speed based on real device free space. 0: disabled, use dcc->discard_granularity, fixed speed.

By default: enabled

How do you think?

Thanks,

Quoted 258 lines
Quoted 255 lines

IMO, in above cases, we'd better to issue discard with high speed for c), middle speed for b), and low speed for a).

How do you think?

Thanks,

Quoted 246 lines

Thanks,

Quoted 240 lines

Anyway, it comes out undiscarded block makes FTL GC be lower efficient and causing high lifetime overhead.

Let's tune discard speed as below:

a. adjust default issue interval:
original after
min_interval: 50ms 100ms
mid_interval: 500ms 1000ms
max_interval: 60000ms 10000ms

b. if last time we stop issuing discard due to IO interruption of user, let's reset all {min,mid,max}_interval to default one.

c. tune {min,mid,max}_interval with below calculation method:

base_interval = default_interval / 10;
total_interval = default_interval - base_interval; interval = base_interval + total_interval * (100 - dev_util) / 100;

For example:
min_interval (:100ms)
dev_util (%) interval (ms)
0 100
10 91
20 82
30 73
...
80 28
90 19
100 10

---
 fs/f2fs/f2fs.h    | 11 ++++----
 fs/f2fs/segment.c | 64 +++++++++++++++++++++++++++++++++++++----------
 fs/f2fs/segment.h |  9 +++++++
 fs/f2fs/super.c   |  2 +-
 4 files changed, 67 insertions(+), 19 deletions(-)
fs/f2fs/f2fs.h +6 -5
index 273ffdaf4891..a1dd2e1c3cb9 100644
@@ -185,10 +185,9 @@ enum {
 
 #define MAX_DISCARD_BLOCKS(sbi)		BLKS_PER_SEC(sbi)
 #define DEF_MAX_DISCARD_REQUEST		8	/* issue 8 discards per round */
-#define DEF_MIN_DISCARD_ISSUE_TIME	50	/* 50 ms, if exists */
-#define DEF_MID_DISCARD_ISSUE_TIME	500	/* 500 ms, if device busy */
-#define DEF_MAX_DISCARD_ISSUE_TIME	60000	/* 60 s, if no candidates */
-#define DEF_DISCARD_URGENT_UTIL		80	/* do more discard over 80% */
+#define DEF_MIN_DISCARD_ISSUE_TIME	100	/* 100 ms, if exists */
+#define DEF_MID_DISCARD_ISSUE_TIME	1000	/* 1000 ms, if device busy */
+#define DEF_MAX_DISCARD_ISSUE_TIME	10000	/* 10000 ms, if no candidates */
 #define DEF_CP_INTERVAL			60	/* 60 secs */
 #define DEF_IDLE_INTERVAL		5	/* 5 secs */
 
@@ -248,7 +247,8 @@ struct discard_entry {
 };
 
 /* default discard granularity of inner discard thread, unit: block count */
-#define DEFAULT_DISCARD_GRANULARITY		1
+#define MID_DISCARD_GRANULARITY			16
+#define MIN_DISCARD_GRANULARITY			1
 
 /* max discard pend list number */
 #define MAX_PLIST_NUM		512
@@ -330,6 +330,7 @@ struct discard_cmd_control {
 	atomic_t discard_cmd_cnt;		/* # of cached cmd count */
 	struct rb_root root;			/* root of discard rb-tree */
 	bool rbtree_check;			/* config for consistence check */
+	bool io_interrupted;			/* last state of io interrupted */
 };
 
 /* for the list of fsync inodes, used only during recovery */
fs/f2fs/segment.c +51 -13
index 8b52e8dfb12f..9564aaf1f27b 100644
@@ -968,6 +968,44 @@ static void __check_sit_bitmap(struct f2fs_sb_info *sbi,
 #endif
 }
 
+static void __adjust_discard_speed(unsigned int *interval,
+				unsigned int def_interval, int dev_util)
+{
+	unsigned int base_interval, total_interval;
+
+	base_interval = def_interval / 10;
+	total_interval = def_interval - base_interval;
+
+	/*
+	 * if def_interval = 100, adjusted interval should be in range of
+	 * [10, 100].
+	 */
+	*interval = base_interval + total_interval * (100 - dev_util) / 100;
+}
+
+static void __tune_discard_policy(struct f2fs_sb_info *sbi,
+					struct discard_policy *dpolicy)
+{
+	struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
+	int dev_util;
+
+	if (dcc->io_interrupted) {
+		dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
+		dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
+		dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
+		return;
+	}
+
+	dev_util = dev_utilization(sbi);
+
+	__adjust_discard_speed(&dpolicy->min_interval,
+				DEF_MIN_DISCARD_ISSUE_TIME, dev_util);
+	__adjust_discard_speed(&dpolicy->mid_interval,
+				DEF_MID_DISCARD_ISSUE_TIME, dev_util);
+	__adjust_discard_speed(&dpolicy->max_interval,
+				DEF_MAX_DISCARD_ISSUE_TIME, dev_util);
+}
+
 static void __init_discard_policy(struct f2fs_sb_info *sbi,
 				struct discard_policy *dpolicy,
 				int discard_type, unsigned int granularity)
@@ -982,20 +1020,11 @@ static void __init_discard_policy(struct f2fs_sb_info *sbi,
 	dpolicy->io_aware_gran = MAX_PLIST_NUM;
 
 	if (discard_type == DPOLICY_BG) {
-		dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
-		dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
 		dpolicy->io_aware = true;
 		dpolicy->sync = false;
 		dpolicy->ordered = true;
-		if (utilization(sbi) > DEF_DISCARD_URGENT_UTIL) {
-			dpolicy->granularity = 1;
-			dpolicy->max_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		}
+		__tune_discard_policy(sbi, dpolicy);
 	} else if (discard_type == DPOLICY_FORCE) {
-		dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
-		dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
 		dpolicy->io_aware = false;
 	} else if (discard_type == DPOLICY_FSTRIM) {
 		dpolicy->io_aware = false;
@@ -1353,6 +1382,8 @@ static unsigned int __issue_discard_cmd_orderly(struct f2fs_sb_info *sbi,
 	if (!issued && io_interrupted)
 		issued = -1;
 
+	dcc->io_interrupted = io_interrupted;
+
 	return issued;
 }
 
@@ -1370,7 +1401,7 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi,
 		if (i + 1 < dpolicy->granularity)
 			break;
 
-		if (i < DEFAULT_DISCARD_GRANULARITY && dpolicy->ordered)
+		if (i < MID_DISCARD_GRANULARITY && dpolicy->ordered)
 			return __issue_discard_cmd_orderly(sbi, dpolicy);
 
 		pend_list = &dcc->pend_list[i];
@@ -1407,6 +1438,8 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi,
 	if (!issued && io_interrupted)
 		issued = -1;
 
+	dcc->io_interrupted = io_interrupted;
+
 	return issued;
 }
 
@@ -1576,7 +1609,11 @@ static int issue_discard_thread(void *data)
 	struct f2fs_sb_info *sbi = data;
 	struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
 	wait_queue_head_t *q = &dcc->discard_wait_queue;
-	struct discard_policy dpolicy;
+	struct discard_policy dpolicy = {
+		.min_interval = DEF_MIN_DISCARD_ISSUE_TIME,
+		.mid_interval = DEF_MID_DISCARD_ISSUE_TIME,
+		.max_interval = DEF_MAX_DISCARD_ISSUE_TIME,
+	};
 	unsigned int wait_ms = DEF_MIN_DISCARD_ISSUE_TIME;
 	int issued;
 
@@ -1929,7 +1966,7 @@ static int create_discard_cmd_control(struct f2fs_sb_info *sbi)
 	if (!dcc)
 		return -ENOMEM;
 
-	dcc->discard_granularity = DEFAULT_DISCARD_GRANULARITY;
+	dcc->discard_granularity = MIN_DISCARD_GRANULARITY;
 	INIT_LIST_HEAD(&dcc->entry_list);
 	for (i = 0; i < MAX_PLIST_NUM; i++)
 		INIT_LIST_HEAD(&dcc->pend_list[i]);
@@ -1945,6 +1982,7 @@ static int create_discard_cmd_control(struct f2fs_sb_info *sbi)
 	dcc->next_pos = 0;
 	dcc->root = RB_ROOT;
 	dcc->rbtree_check = false;
+	dcc->io_interrupted = false;
 
 	init_waitqueue_head(&dcc->discard_wait_queue);
 	SM_I(sbi)->dcc_info = dcc;
fs/f2fs/segment.h +9 -0
index 422b0ceb1eaa..63b4da72cd34 100644
@@ -616,6 +616,15 @@ static inline int utilization(struct f2fs_sb_info *sbi)
 					sbi->user_block_count);
 }
 
+static inline int dev_utilization(struct f2fs_sb_info *sbi)
+{
+	unsigned int dev_blks;
+
+	dev_blks = valid_user_blocks(sbi) + SM_I(sbi)->dcc_info->undiscard_blks;
+	return div_u64((u64)dev_blks * 100,
+			MAIN_SEGS(sbi) << sbi->log_blocks_per_seg);
+}
+
 /*
  * Sometimes f2fs may be better to drop out-of-place update policy.
  * And, users can control the policy through sysfs entries.
fs/f2fs/super.c +1 -1
index b055f2ea77c5..55ed76daad23 100644
@@ -2862,7 +2862,7 @@ static void f2fs_tuning_parameters(struct f2fs_sb_info *sbi)
 	/* adjust parameters according to the volume size */
 	if (sm_i->main_segments <= SMALL_VOLUME_SEGMENTS) {
 		F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;
-		sm_i->dcc_info->discard_granularity = 1;
+		sm_i->dcc_info->discard_granularity = MIN_DISCARD_GRANULARITY;
 		sm_i->ipu_policy = 1 << F2FS_IPU_FORCE;
 	}
 
Signature · 1 line
2.18.0.rc1

.

.

maintainer
#6 lore raw

Re: [PATCH 2/2] f2fs: tune discard speed with storage usage rate

Quoted 34 lines · Chao Yu
Quoted 24 lines · Jaegeuk Kim
Quoted 23 lines · Chao Yu
Quoted 7 lines · Jaegeuk Kim
Quoted 3 lines · Chao Yu

Previously, discard speed was fixed mostly, and in high usage rate device, we will speed up issuing discard, but it doesn't make sense that in a non-full filesystem, we still issue discard with slow speed.

Could you please elaborate the problem in more detail? The speed depends on how many candidates?

undiscard blocks are all 4k granularity.
a) utility: filesystem: 20% + undiscard blocks: 20% = flash storage: 40%
b) utility: filesystem: 40% + undiscard blocks: 25% = flash storage: 65%
c) utility: filesystem: 60% + undiscard blocks: 30% = flash storage: 100%

1. for case c), we need to speed up issuing discard based on utilization of "filesystem + undiscard" instead of just utilization of filesystem.

fs/f2fs/segment.c +0 -4
-		if (utilization(sbi) > DEF_DISCARD_URGENT_UTIL) {
-			dpolicy->granularity = 1;
-			dpolicy->max_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		}
Quoted 8 lines
Quoted 3 lines

2. If free space in storage touches therein threshold, performance will be very sensitive. In low-end storage, with high usage in space, even free space is reduced by 1%, performance will decrease a lot.

So, we may need to distinguish low-end vs. high-end storage. In high-end case, it'd be better to avoid IO contention, while low-end device wants to get more discard commands as much as possible. So, how about adding an option for this as a tunable point?

Quoted 7 lines

Agreed, how about adding a sysfs entry discard_tunning:
1: enabled, use 4k granularity, self-adapted speed based on real device free space. 0: disabled, use dcc->discard_granularity, fixed speed.

By default: enabled

How do you think?

I don't think this is proper with a sysfs entry, since we already know the device type when mounting the partition. We won't require to change the policy on the fly. And, I still don't get to change the default.

Quoted 261 lines

Thanks,

Quoted 258 lines
Quoted 255 lines

IMO, in above cases, we'd better to issue discard with high speed for c), middle speed for b), and low speed for a).

How do you think?

Thanks,

Quoted 246 lines

Thanks,

Quoted 240 lines

Anyway, it comes out undiscarded block makes FTL GC be lower efficient and causing high lifetime overhead.

Let's tune discard speed as below:

a. adjust default issue interval:
original after
min_interval: 50ms 100ms
mid_interval: 500ms 1000ms
max_interval: 60000ms 10000ms

b. if last time we stop issuing discard due to IO interruption of user, let's reset all {min,mid,max}_interval to default one.

c. tune {min,mid,max}_interval with below calculation method:

base_interval = default_interval / 10;
total_interval = default_interval - base_interval; interval = base_interval + total_interval * (100 - dev_util) / 100;

For example:
min_interval (:100ms)
dev_util (%) interval (ms)
0 100
10 91
20 82
30 73
...
80 28
90 19
100 10

---
 fs/f2fs/f2fs.h    | 11 ++++----
 fs/f2fs/segment.c | 64 +++++++++++++++++++++++++++++++++++++----------
 fs/f2fs/segment.h |  9 +++++++
 fs/f2fs/super.c   |  2 +-
 4 files changed, 67 insertions(+), 19 deletions(-)
fs/f2fs/f2fs.h +6 -5
index 273ffdaf4891..a1dd2e1c3cb9 100644
@@ -185,10 +185,9 @@ enum {
 
 #define MAX_DISCARD_BLOCKS(sbi)		BLKS_PER_SEC(sbi)
 #define DEF_MAX_DISCARD_REQUEST		8	/* issue 8 discards per round */
-#define DEF_MIN_DISCARD_ISSUE_TIME	50	/* 50 ms, if exists */
-#define DEF_MID_DISCARD_ISSUE_TIME	500	/* 500 ms, if device busy */
-#define DEF_MAX_DISCARD_ISSUE_TIME	60000	/* 60 s, if no candidates */
-#define DEF_DISCARD_URGENT_UTIL		80	/* do more discard over 80% */
+#define DEF_MIN_DISCARD_ISSUE_TIME	100	/* 100 ms, if exists */
+#define DEF_MID_DISCARD_ISSUE_TIME	1000	/* 1000 ms, if device busy */
+#define DEF_MAX_DISCARD_ISSUE_TIME	10000	/* 10000 ms, if no candidates */
 #define DEF_CP_INTERVAL			60	/* 60 secs */
 #define DEF_IDLE_INTERVAL		5	/* 5 secs */
 
@@ -248,7 +247,8 @@ struct discard_entry {
 };
 
 /* default discard granularity of inner discard thread, unit: block count */
-#define DEFAULT_DISCARD_GRANULARITY		1
+#define MID_DISCARD_GRANULARITY			16
+#define MIN_DISCARD_GRANULARITY			1
 
 /* max discard pend list number */
 #define MAX_PLIST_NUM		512
@@ -330,6 +330,7 @@ struct discard_cmd_control {
 	atomic_t discard_cmd_cnt;		/* # of cached cmd count */
 	struct rb_root root;			/* root of discard rb-tree */
 	bool rbtree_check;			/* config for consistence check */
+	bool io_interrupted;			/* last state of io interrupted */
 };
 
 /* for the list of fsync inodes, used only during recovery */
fs/f2fs/segment.c +51 -13
index 8b52e8dfb12f..9564aaf1f27b 100644
@@ -968,6 +968,44 @@ static void __check_sit_bitmap(struct f2fs_sb_info *sbi,
 #endif
 }
 
+static void __adjust_discard_speed(unsigned int *interval,
+				unsigned int def_interval, int dev_util)
+{
+	unsigned int base_interval, total_interval;
+
+	base_interval = def_interval / 10;
+	total_interval = def_interval - base_interval;
+
+	/*
+	 * if def_interval = 100, adjusted interval should be in range of
+	 * [10, 100].
+	 */
+	*interval = base_interval + total_interval * (100 - dev_util) / 100;
+}
+
+static void __tune_discard_policy(struct f2fs_sb_info *sbi,
+					struct discard_policy *dpolicy)
+{
+	struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
+	int dev_util;
+
+	if (dcc->io_interrupted) {
+		dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
+		dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
+		dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
+		return;
+	}
+
+	dev_util = dev_utilization(sbi);
+
+	__adjust_discard_speed(&dpolicy->min_interval,
+				DEF_MIN_DISCARD_ISSUE_TIME, dev_util);
+	__adjust_discard_speed(&dpolicy->mid_interval,
+				DEF_MID_DISCARD_ISSUE_TIME, dev_util);
+	__adjust_discard_speed(&dpolicy->max_interval,
+				DEF_MAX_DISCARD_ISSUE_TIME, dev_util);
+}
+
 static void __init_discard_policy(struct f2fs_sb_info *sbi,
 				struct discard_policy *dpolicy,
 				int discard_type, unsigned int granularity)
@@ -982,20 +1020,11 @@ static void __init_discard_policy(struct f2fs_sb_info *sbi,
 	dpolicy->io_aware_gran = MAX_PLIST_NUM;
 
 	if (discard_type == DPOLICY_BG) {
-		dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
-		dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
 		dpolicy->io_aware = true;
 		dpolicy->sync = false;
 		dpolicy->ordered = true;
-		if (utilization(sbi) > DEF_DISCARD_URGENT_UTIL) {
-			dpolicy->granularity = 1;
-			dpolicy->max_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		}
+		__tune_discard_policy(sbi, dpolicy);
 	} else if (discard_type == DPOLICY_FORCE) {
-		dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
-		dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
 		dpolicy->io_aware = false;
 	} else if (discard_type == DPOLICY_FSTRIM) {
 		dpolicy->io_aware = false;
@@ -1353,6 +1382,8 @@ static unsigned int __issue_discard_cmd_orderly(struct f2fs_sb_info *sbi,
 	if (!issued && io_interrupted)
 		issued = -1;
 
+	dcc->io_interrupted = io_interrupted;
+
 	return issued;
 }
 
@@ -1370,7 +1401,7 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi,
 		if (i + 1 < dpolicy->granularity)
 			break;
 
-		if (i < DEFAULT_DISCARD_GRANULARITY && dpolicy->ordered)
+		if (i < MID_DISCARD_GRANULARITY && dpolicy->ordered)
 			return __issue_discard_cmd_orderly(sbi, dpolicy);
 
 		pend_list = &dcc->pend_list[i];
@@ -1407,6 +1438,8 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi,
 	if (!issued && io_interrupted)
 		issued = -1;
 
+	dcc->io_interrupted = io_interrupted;
+
 	return issued;
 }
 
@@ -1576,7 +1609,11 @@ static int issue_discard_thread(void *data)
 	struct f2fs_sb_info *sbi = data;
 	struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
 	wait_queue_head_t *q = &dcc->discard_wait_queue;
-	struct discard_policy dpolicy;
+	struct discard_policy dpolicy = {
+		.min_interval = DEF_MIN_DISCARD_ISSUE_TIME,
+		.mid_interval = DEF_MID_DISCARD_ISSUE_TIME,
+		.max_interval = DEF_MAX_DISCARD_ISSUE_TIME,
+	};
 	unsigned int wait_ms = DEF_MIN_DISCARD_ISSUE_TIME;
 	int issued;
 
@@ -1929,7 +1966,7 @@ static int create_discard_cmd_control(struct f2fs_sb_info *sbi)
 	if (!dcc)
 		return -ENOMEM;
 
-	dcc->discard_granularity = DEFAULT_DISCARD_GRANULARITY;
+	dcc->discard_granularity = MIN_DISCARD_GRANULARITY;
 	INIT_LIST_HEAD(&dcc->entry_list);
 	for (i = 0; i < MAX_PLIST_NUM; i++)
 		INIT_LIST_HEAD(&dcc->pend_list[i]);
@@ -1945,6 +1982,7 @@ static int create_discard_cmd_control(struct f2fs_sb_info *sbi)
 	dcc->next_pos = 0;
 	dcc->root = RB_ROOT;
 	dcc->rbtree_check = false;
+	dcc->io_interrupted = false;
 
 	init_waitqueue_head(&dcc->discard_wait_queue);
 	SM_I(sbi)->dcc_info = dcc;
fs/f2fs/segment.h +9 -0
index 422b0ceb1eaa..63b4da72cd34 100644
@@ -616,6 +616,15 @@ static inline int utilization(struct f2fs_sb_info *sbi)
 					sbi->user_block_count);
 }
 
+static inline int dev_utilization(struct f2fs_sb_info *sbi)
+{
+	unsigned int dev_blks;
+
+	dev_blks = valid_user_blocks(sbi) + SM_I(sbi)->dcc_info->undiscard_blks;
+	return div_u64((u64)dev_blks * 100,
+			MAIN_SEGS(sbi) << sbi->log_blocks_per_seg);
+}
+
 /*
  * Sometimes f2fs may be better to drop out-of-place update policy.
  * And, users can control the policy through sysfs entries.
fs/f2fs/super.c +1 -1
index b055f2ea77c5..55ed76daad23 100644
@@ -2862,7 +2862,7 @@ static void f2fs_tuning_parameters(struct f2fs_sb_info *sbi)
 	/* adjust parameters according to the volume size */
 	if (sm_i->main_segments <= SMALL_VOLUME_SEGMENTS) {
 		F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;
-		sm_i->dcc_info->discard_granularity = 1;
+		sm_i->dcc_info->discard_granularity = MIN_DISCARD_GRANULARITY;
 		sm_i->ipu_policy = 1 << F2FS_IPU_FORCE;
 	}
 
Signature · 1 line
2.18.0.rc1

.

.

author
#7 lore raw

Re: [PATCH 2/2] f2fs: tune discard speed with storage usage rate

Quoted 39 lines · Jaegeuk Kim
Quoted 38 lines · Chao Yu
Quoted 24 lines · Jaegeuk Kim
Quoted 23 lines · Chao Yu
Quoted 7 lines · Jaegeuk Kim
Quoted 3 lines · Chao Yu

Previously, discard speed was fixed mostly, and in high usage rate device, we will speed up issuing discard, but it doesn't make sense that in a non-full filesystem, we still issue discard with slow speed.

Could you please elaborate the problem in more detail? The speed depends on how many candidates?

undiscard blocks are all 4k granularity.
a) utility: filesystem: 20% + undiscard blocks: 20% = flash storage: 40%
b) utility: filesystem: 40% + undiscard blocks: 25% = flash storage: 65%
c) utility: filesystem: 60% + undiscard blocks: 30% = flash storage: 100%

1. for case c), we need to speed up issuing discard based on utilization of "filesystem + undiscard" instead of just utilization of filesystem.

fs/f2fs/segment.c +0 -4
-		if (utilization(sbi) > DEF_DISCARD_URGENT_UTIL) {
-			dpolicy->granularity = 1;
-			dpolicy->max_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		}
Quoted 8 lines
Quoted 3 lines

2. If free space in storage touches therein threshold, performance will be very sensitive. In low-end storage, with high usage in space, even free space is reduced by 1%, performance will decrease a lot.

So, we may need to distinguish low-end vs. high-end storage. In high-end case, it'd be better to avoid IO contention, while low-end device wants to get more discard commands as much as possible. So, how about adding an option for this as a tunable point?

Agreed, how about adding a sysfs entry discard_tunning:
1: enabled, use 4k granularity, self-adapted speed based on real device free space. 0: disabled, use dcc->discard_granularity, fixed speed.

Quoted 5 lines
Quoted 3 lines

By default: enabled

How do you think?

I don't think this is proper with a sysfs entry, since we already know the

You mean by storage capacity? <= 32GB means low-end?

Thanks,

Quoted 267 lines

device type when mounting the partition. We won't require to change the policy on the fly. And, I still don't get to change the default.

Quoted 261 lines

Thanks,

Quoted 258 lines
Quoted 255 lines

IMO, in above cases, we'd better to issue discard with high speed for c), middle speed for b), and low speed for a).

How do you think?

Thanks,

Quoted 246 lines

Thanks,

Quoted 240 lines

Anyway, it comes out undiscarded block makes FTL GC be lower efficient and causing high lifetime overhead.

Let's tune discard speed as below:

a. adjust default issue interval:
original after
min_interval: 50ms 100ms
mid_interval: 500ms 1000ms
max_interval: 60000ms 10000ms

b. if last time we stop issuing discard due to IO interruption of user, let's reset all {min,mid,max}_interval to default one.

c. tune {min,mid,max}_interval with below calculation method:

base_interval = default_interval / 10;
total_interval = default_interval - base_interval; interval = base_interval + total_interval * (100 - dev_util) / 100;

For example:
min_interval (:100ms)
dev_util (%) interval (ms)
0 100
10 91
20 82
30 73
...
80 28
90 19
100 10

---
 fs/f2fs/f2fs.h    | 11 ++++----
 fs/f2fs/segment.c | 64 +++++++++++++++++++++++++++++++++++++----------
 fs/f2fs/segment.h |  9 +++++++
 fs/f2fs/super.c   |  2 +-
 4 files changed, 67 insertions(+), 19 deletions(-)
fs/f2fs/f2fs.h +6 -5
index 273ffdaf4891..a1dd2e1c3cb9 100644
@@ -185,10 +185,9 @@ enum {
 
 #define MAX_DISCARD_BLOCKS(sbi)		BLKS_PER_SEC(sbi)
 #define DEF_MAX_DISCARD_REQUEST		8	/* issue 8 discards per round */
-#define DEF_MIN_DISCARD_ISSUE_TIME	50	/* 50 ms, if exists */
-#define DEF_MID_DISCARD_ISSUE_TIME	500	/* 500 ms, if device busy */
-#define DEF_MAX_DISCARD_ISSUE_TIME	60000	/* 60 s, if no candidates */
-#define DEF_DISCARD_URGENT_UTIL		80	/* do more discard over 80% */
+#define DEF_MIN_DISCARD_ISSUE_TIME	100	/* 100 ms, if exists */
+#define DEF_MID_DISCARD_ISSUE_TIME	1000	/* 1000 ms, if device busy */
+#define DEF_MAX_DISCARD_ISSUE_TIME	10000	/* 10000 ms, if no candidates */
 #define DEF_CP_INTERVAL			60	/* 60 secs */
 #define DEF_IDLE_INTERVAL		5	/* 5 secs */
 
@@ -248,7 +247,8 @@ struct discard_entry {
 };
 
 /* default discard granularity of inner discard thread, unit: block count */
-#define DEFAULT_DISCARD_GRANULARITY		1
+#define MID_DISCARD_GRANULARITY			16
+#define MIN_DISCARD_GRANULARITY			1
 
 /* max discard pend list number */
 #define MAX_PLIST_NUM		512
@@ -330,6 +330,7 @@ struct discard_cmd_control {
 	atomic_t discard_cmd_cnt;		/* # of cached cmd count */
 	struct rb_root root;			/* root of discard rb-tree */
 	bool rbtree_check;			/* config for consistence check */
+	bool io_interrupted;			/* last state of io interrupted */
 };
 
 /* for the list of fsync inodes, used only during recovery */
fs/f2fs/segment.c +51 -13
index 8b52e8dfb12f..9564aaf1f27b 100644
@@ -968,6 +968,44 @@ static void __check_sit_bitmap(struct f2fs_sb_info *sbi,
 #endif
 }
 
+static void __adjust_discard_speed(unsigned int *interval,
+				unsigned int def_interval, int dev_util)
+{
+	unsigned int base_interval, total_interval;
+
+	base_interval = def_interval / 10;
+	total_interval = def_interval - base_interval;
+
+	/*
+	 * if def_interval = 100, adjusted interval should be in range of
+	 * [10, 100].
+	 */
+	*interval = base_interval + total_interval * (100 - dev_util) / 100;
+}
+
+static void __tune_discard_policy(struct f2fs_sb_info *sbi,
+					struct discard_policy *dpolicy)
+{
+	struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
+	int dev_util;
+
+	if (dcc->io_interrupted) {
+		dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
+		dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
+		dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
+		return;
+	}
+
+	dev_util = dev_utilization(sbi);
+
+	__adjust_discard_speed(&dpolicy->min_interval,
+				DEF_MIN_DISCARD_ISSUE_TIME, dev_util);
+	__adjust_discard_speed(&dpolicy->mid_interval,
+				DEF_MID_DISCARD_ISSUE_TIME, dev_util);
+	__adjust_discard_speed(&dpolicy->max_interval,
+				DEF_MAX_DISCARD_ISSUE_TIME, dev_util);
+}
+
 static void __init_discard_policy(struct f2fs_sb_info *sbi,
 				struct discard_policy *dpolicy,
 				int discard_type, unsigned int granularity)
@@ -982,20 +1020,11 @@ static void __init_discard_policy(struct f2fs_sb_info *sbi,
 	dpolicy->io_aware_gran = MAX_PLIST_NUM;
 
 	if (discard_type == DPOLICY_BG) {
-		dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
-		dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
 		dpolicy->io_aware = true;
 		dpolicy->sync = false;
 		dpolicy->ordered = true;
-		if (utilization(sbi) > DEF_DISCARD_URGENT_UTIL) {
-			dpolicy->granularity = 1;
-			dpolicy->max_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		}
+		__tune_discard_policy(sbi, dpolicy);
 	} else if (discard_type == DPOLICY_FORCE) {
-		dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
-		dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
 		dpolicy->io_aware = false;
 	} else if (discard_type == DPOLICY_FSTRIM) {
 		dpolicy->io_aware = false;
@@ -1353,6 +1382,8 @@ static unsigned int __issue_discard_cmd_orderly(struct f2fs_sb_info *sbi,
 	if (!issued && io_interrupted)
 		issued = -1;
 
+	dcc->io_interrupted = io_interrupted;
+
 	return issued;
 }
 
@@ -1370,7 +1401,7 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi,
 		if (i + 1 < dpolicy->granularity)
 			break;
 
-		if (i < DEFAULT_DISCARD_GRANULARITY && dpolicy->ordered)
+		if (i < MID_DISCARD_GRANULARITY && dpolicy->ordered)
 			return __issue_discard_cmd_orderly(sbi, dpolicy);
 
 		pend_list = &dcc->pend_list[i];
@@ -1407,6 +1438,8 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi,
 	if (!issued && io_interrupted)
 		issued = -1;
 
+	dcc->io_interrupted = io_interrupted;
+
 	return issued;
 }
 
@@ -1576,7 +1609,11 @@ static int issue_discard_thread(void *data)
 	struct f2fs_sb_info *sbi = data;
 	struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
 	wait_queue_head_t *q = &dcc->discard_wait_queue;
-	struct discard_policy dpolicy;
+	struct discard_policy dpolicy = {
+		.min_interval = DEF_MIN_DISCARD_ISSUE_TIME,
+		.mid_interval = DEF_MID_DISCARD_ISSUE_TIME,
+		.max_interval = DEF_MAX_DISCARD_ISSUE_TIME,
+	};
 	unsigned int wait_ms = DEF_MIN_DISCARD_ISSUE_TIME;
 	int issued;
 
@@ -1929,7 +1966,7 @@ static int create_discard_cmd_control(struct f2fs_sb_info *sbi)
 	if (!dcc)
 		return -ENOMEM;
 
-	dcc->discard_granularity = DEFAULT_DISCARD_GRANULARITY;
+	dcc->discard_granularity = MIN_DISCARD_GRANULARITY;
 	INIT_LIST_HEAD(&dcc->entry_list);
 	for (i = 0; i < MAX_PLIST_NUM; i++)
 		INIT_LIST_HEAD(&dcc->pend_list[i]);
@@ -1945,6 +1982,7 @@ static int create_discard_cmd_control(struct f2fs_sb_info *sbi)
 	dcc->next_pos = 0;
 	dcc->root = RB_ROOT;
 	dcc->rbtree_check = false;
+	dcc->io_interrupted = false;
 
 	init_waitqueue_head(&dcc->discard_wait_queue);
 	SM_I(sbi)->dcc_info = dcc;
fs/f2fs/segment.h +9 -0
index 422b0ceb1eaa..63b4da72cd34 100644
@@ -616,6 +616,15 @@ static inline int utilization(struct f2fs_sb_info *sbi)
 					sbi->user_block_count);
 }
 
+static inline int dev_utilization(struct f2fs_sb_info *sbi)
+{
+	unsigned int dev_blks;
+
+	dev_blks = valid_user_blocks(sbi) + SM_I(sbi)->dcc_info->undiscard_blks;
+	return div_u64((u64)dev_blks * 100,
+			MAIN_SEGS(sbi) << sbi->log_blocks_per_seg);
+}
+
 /*
  * Sometimes f2fs may be better to drop out-of-place update policy.
  * And, users can control the policy through sysfs entries.
fs/f2fs/super.c +1 -1
index b055f2ea77c5..55ed76daad23 100644
@@ -2862,7 +2862,7 @@ static void f2fs_tuning_parameters(struct f2fs_sb_info *sbi)
 	/* adjust parameters according to the volume size */
 	if (sm_i->main_segments <= SMALL_VOLUME_SEGMENTS) {
 		F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;
-		sm_i->dcc_info->discard_granularity = 1;
+		sm_i->dcc_info->discard_granularity = MIN_DISCARD_GRANULARITY;
 		sm_i->ipu_policy = 1 << F2FS_IPU_FORCE;
 	}
 
Signature · 1 line
2.18.0.rc1

.

.

.

maintainer
#8 lore raw

Re: [PATCH 2/2] f2fs: tune discard speed with storage usage rate

Quoted 40 lines · Chao Yu
Quoted 39 lines · Jaegeuk Kim
Quoted 38 lines · Chao Yu
Quoted 24 lines · Jaegeuk Kim
Quoted 23 lines · Chao Yu
Quoted 7 lines · Jaegeuk Kim
Quoted 3 lines · Chao Yu

Previously, discard speed was fixed mostly, and in high usage rate device, we will speed up issuing discard, but it doesn't make sense that in a non-full filesystem, we still issue discard with slow speed.

Could you please elaborate the problem in more detail? The speed depends on how many candidates?

undiscard blocks are all 4k granularity.
a) utility: filesystem: 20% + undiscard blocks: 20% = flash storage: 40%
b) utility: filesystem: 40% + undiscard blocks: 25% = flash storage: 65%
c) utility: filesystem: 60% + undiscard blocks: 30% = flash storage: 100%

1. for case c), we need to speed up issuing discard based on utilization of "filesystem + undiscard" instead of just utilization of filesystem.

(quoted diff) +0 -4
-		if (utilization(sbi) > DEF_DISCARD_URGENT_UTIL) {
-			dpolicy->granularity = 1;
-			dpolicy->max_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		}
Quoted 8 lines
Quoted 3 lines

2. If free space in storage touches therein threshold, performance will be very sensitive. In low-end storage, with high usage in space, even free space is reduced by 1%, performance will decrease a lot.

So, we may need to distinguish low-end vs. high-end storage. In high-end case, it'd be better to avoid IO contention, while low-end device wants to get more discard commands as much as possible. So, how about adding an option for this as a tunable point?

Agreed, how about adding a sysfs entry discard_tunning:
1: enabled, use 4k granularity, self-adapted speed based on real device free space. 0: disabled, use dcc->discard_granularity, fixed speed.

Quoted 7 lines
Quoted 5 lines
Quoted 3 lines

By default: enabled

How do you think?

I don't think this is proper with a sysfs entry, since we already know the

You mean by storage capacity? <= 32GB means low-end?

Yes, that's current condition to judge it. If there is any other method, it'd be better to change it.

Quoted 270 lines

Thanks,

Quoted 267 lines

device type when mounting the partition. We won't require to change the policy on the fly. And, I still don't get to change the default.

Quoted 261 lines

Thanks,

Quoted 258 lines
Quoted 255 lines

IMO, in above cases, we'd better to issue discard with high speed for c), middle speed for b), and low speed for a).

How do you think?

Thanks,

Quoted 246 lines

Thanks,

Quoted 240 lines

Anyway, it comes out undiscarded block makes FTL GC be lower efficient and causing high lifetime overhead.

Let's tune discard speed as below:

a. adjust default issue interval:
original after
min_interval: 50ms 100ms
mid_interval: 500ms 1000ms
max_interval: 60000ms 10000ms

b. if last time we stop issuing discard due to IO interruption of user, let's reset all {min,mid,max}_interval to default one.

c. tune {min,mid,max}_interval with below calculation method:

base_interval = default_interval / 10;
total_interval = default_interval - base_interval; interval = base_interval + total_interval * (100 - dev_util) / 100;

For example:
min_interval (:100ms)
dev_util (%) interval (ms)
0 100
10 91
20 82
30 73
...
80 28
90 19
100 10

---
 fs/f2fs/f2fs.h    | 11 ++++----
 fs/f2fs/segment.c | 64 +++++++++++++++++++++++++++++++++++++----------
 fs/f2fs/segment.h |  9 +++++++
 fs/f2fs/super.c   |  2 +-
 4 files changed, 67 insertions(+), 19 deletions(-)
fs/f2fs/f2fs.h +6 -5
index 273ffdaf4891..a1dd2e1c3cb9 100644
@@ -185,10 +185,9 @@ enum {
 
 #define MAX_DISCARD_BLOCKS(sbi)		BLKS_PER_SEC(sbi)
 #define DEF_MAX_DISCARD_REQUEST		8	/* issue 8 discards per round */
-#define DEF_MIN_DISCARD_ISSUE_TIME	50	/* 50 ms, if exists */
-#define DEF_MID_DISCARD_ISSUE_TIME	500	/* 500 ms, if device busy */
-#define DEF_MAX_DISCARD_ISSUE_TIME	60000	/* 60 s, if no candidates */
-#define DEF_DISCARD_URGENT_UTIL		80	/* do more discard over 80% */
+#define DEF_MIN_DISCARD_ISSUE_TIME	100	/* 100 ms, if exists */
+#define DEF_MID_DISCARD_ISSUE_TIME	1000	/* 1000 ms, if device busy */
+#define DEF_MAX_DISCARD_ISSUE_TIME	10000	/* 10000 ms, if no candidates */
 #define DEF_CP_INTERVAL			60	/* 60 secs */
 #define DEF_IDLE_INTERVAL		5	/* 5 secs */
 
@@ -248,7 +247,8 @@ struct discard_entry {
 };
 
 /* default discard granularity of inner discard thread, unit: block count */
-#define DEFAULT_DISCARD_GRANULARITY		1
+#define MID_DISCARD_GRANULARITY			16
+#define MIN_DISCARD_GRANULARITY			1
 
 /* max discard pend list number */
 #define MAX_PLIST_NUM		512
@@ -330,6 +330,7 @@ struct discard_cmd_control {
 	atomic_t discard_cmd_cnt;		/* # of cached cmd count */
 	struct rb_root root;			/* root of discard rb-tree */
 	bool rbtree_check;			/* config for consistence check */
+	bool io_interrupted;			/* last state of io interrupted */
 };
 
 /* for the list of fsync inodes, used only during recovery */
fs/f2fs/segment.c +51 -13
index 8b52e8dfb12f..9564aaf1f27b 100644
@@ -968,6 +968,44 @@ static void __check_sit_bitmap(struct f2fs_sb_info *sbi,
 #endif
 }
 
+static void __adjust_discard_speed(unsigned int *interval,
+				unsigned int def_interval, int dev_util)
+{
+	unsigned int base_interval, total_interval;
+
+	base_interval = def_interval / 10;
+	total_interval = def_interval - base_interval;
+
+	/*
+	 * if def_interval = 100, adjusted interval should be in range of
+	 * [10, 100].
+	 */
+	*interval = base_interval + total_interval * (100 - dev_util) / 100;
+}
+
+static void __tune_discard_policy(struct f2fs_sb_info *sbi,
+					struct discard_policy *dpolicy)
+{
+	struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
+	int dev_util;
+
+	if (dcc->io_interrupted) {
+		dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
+		dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
+		dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
+		return;
+	}
+
+	dev_util = dev_utilization(sbi);
+
+	__adjust_discard_speed(&dpolicy->min_interval,
+				DEF_MIN_DISCARD_ISSUE_TIME, dev_util);
+	__adjust_discard_speed(&dpolicy->mid_interval,
+				DEF_MID_DISCARD_ISSUE_TIME, dev_util);
+	__adjust_discard_speed(&dpolicy->max_interval,
+				DEF_MAX_DISCARD_ISSUE_TIME, dev_util);
+}
+
 static void __init_discard_policy(struct f2fs_sb_info *sbi,
 				struct discard_policy *dpolicy,
 				int discard_type, unsigned int granularity)
@@ -982,20 +1020,11 @@ static void __init_discard_policy(struct f2fs_sb_info *sbi,
 	dpolicy->io_aware_gran = MAX_PLIST_NUM;
 
 	if (discard_type == DPOLICY_BG) {
-		dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
-		dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
 		dpolicy->io_aware = true;
 		dpolicy->sync = false;
 		dpolicy->ordered = true;
-		if (utilization(sbi) > DEF_DISCARD_URGENT_UTIL) {
-			dpolicy->granularity = 1;
-			dpolicy->max_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		}
+		__tune_discard_policy(sbi, dpolicy);
 	} else if (discard_type == DPOLICY_FORCE) {
-		dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
-		dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
 		dpolicy->io_aware = false;
 	} else if (discard_type == DPOLICY_FSTRIM) {
 		dpolicy->io_aware = false;
@@ -1353,6 +1382,8 @@ static unsigned int __issue_discard_cmd_orderly(struct f2fs_sb_info *sbi,
 	if (!issued && io_interrupted)
 		issued = -1;
 
+	dcc->io_interrupted = io_interrupted;
+
 	return issued;
 }
 
@@ -1370,7 +1401,7 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi,
 		if (i + 1 < dpolicy->granularity)
 			break;
 
-		if (i < DEFAULT_DISCARD_GRANULARITY && dpolicy->ordered)
+		if (i < MID_DISCARD_GRANULARITY && dpolicy->ordered)
 			return __issue_discard_cmd_orderly(sbi, dpolicy);
 
 		pend_list = &dcc->pend_list[i];
@@ -1407,6 +1438,8 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi,
 	if (!issued && io_interrupted)
 		issued = -1;
 
+	dcc->io_interrupted = io_interrupted;
+
 	return issued;
 }
 
@@ -1576,7 +1609,11 @@ static int issue_discard_thread(void *data)
 	struct f2fs_sb_info *sbi = data;
 	struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
 	wait_queue_head_t *q = &dcc->discard_wait_queue;
-	struct discard_policy dpolicy;
+	struct discard_policy dpolicy = {
+		.min_interval = DEF_MIN_DISCARD_ISSUE_TIME,
+		.mid_interval = DEF_MID_DISCARD_ISSUE_TIME,
+		.max_interval = DEF_MAX_DISCARD_ISSUE_TIME,
+	};
 	unsigned int wait_ms = DEF_MIN_DISCARD_ISSUE_TIME;
 	int issued;
 
@@ -1929,7 +1966,7 @@ static int create_discard_cmd_control(struct f2fs_sb_info *sbi)
 	if (!dcc)
 		return -ENOMEM;
 
-	dcc->discard_granularity = DEFAULT_DISCARD_GRANULARITY;
+	dcc->discard_granularity = MIN_DISCARD_GRANULARITY;
 	INIT_LIST_HEAD(&dcc->entry_list);
 	for (i = 0; i < MAX_PLIST_NUM; i++)
 		INIT_LIST_HEAD(&dcc->pend_list[i]);
@@ -1945,6 +1982,7 @@ static int create_discard_cmd_control(struct f2fs_sb_info *sbi)
 	dcc->next_pos = 0;
 	dcc->root = RB_ROOT;
 	dcc->rbtree_check = false;
+	dcc->io_interrupted = false;
 
 	init_waitqueue_head(&dcc->discard_wait_queue);
 	SM_I(sbi)->dcc_info = dcc;
fs/f2fs/segment.h +9 -0
index 422b0ceb1eaa..63b4da72cd34 100644
@@ -616,6 +616,15 @@ static inline int utilization(struct f2fs_sb_info *sbi)
 					sbi->user_block_count);
 }
 
+static inline int dev_utilization(struct f2fs_sb_info *sbi)
+{
+	unsigned int dev_blks;
+
+	dev_blks = valid_user_blocks(sbi) + SM_I(sbi)->dcc_info->undiscard_blks;
+	return div_u64((u64)dev_blks * 100,
+			MAIN_SEGS(sbi) << sbi->log_blocks_per_seg);
+}
+
 /*
  * Sometimes f2fs may be better to drop out-of-place update policy.
  * And, users can control the policy through sysfs entries.
fs/f2fs/super.c +1 -1
index b055f2ea77c5..55ed76daad23 100644
@@ -2862,7 +2862,7 @@ static void f2fs_tuning_parameters(struct f2fs_sb_info *sbi)
 	/* adjust parameters according to the volume size */
 	if (sm_i->main_segments <= SMALL_VOLUME_SEGMENTS) {
 		F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;
-		sm_i->dcc_info->discard_granularity = 1;
+		sm_i->dcc_info->discard_granularity = MIN_DISCARD_GRANULARITY;
 		sm_i->ipu_policy = 1 << F2FS_IPU_FORCE;
 	}
 
Signature · 1 line
2.18.0.rc1

.

.

.

author
#9 lore raw

Re: [PATCH 2/2] f2fs: tune discard speed with storage usage rate

Quoted 43 lines · Jaegeuk Kim
Quoted 42 lines · Chao Yu
Quoted 41 lines · Jaegeuk Kim
Quoted 40 lines · Chao Yu
Quoted 24 lines · Jaegeuk Kim
Quoted 23 lines · Chao Yu
Quoted 7 lines · Jaegeuk Kim
Quoted 3 lines · Chao Yu

Previously, discard speed was fixed mostly, and in high usage rate device, we will speed up issuing discard, but it doesn't make sense that in a non-full filesystem, we still issue discard with slow speed.

Could you please elaborate the problem in more detail? The speed depends on how many candidates?

undiscard blocks are all 4k granularity.
a) utility: filesystem: 20% + undiscard blocks: 20% = flash storage: 40%
b) utility: filesystem: 40% + undiscard blocks: 25% = flash storage: 65%
c) utility: filesystem: 60% + undiscard blocks: 30% = flash storage: 100%

1. for case c), we need to speed up issuing discard based on utilization of "filesystem + undiscard" instead of just utilization of filesystem.

(quoted diff) +0 -4
-		if (utilization(sbi) > DEF_DISCARD_URGENT_UTIL) {
-			dpolicy->granularity = 1;
-			dpolicy->max_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		}
Quoted 8 lines
Quoted 3 lines

2. If free space in storage touches therein threshold, performance will be very sensitive. In low-end storage, with high usage in space, even free space is reduced by 1%, performance will decrease a lot.

So, we may need to distinguish low-end vs. high-end storage. In high-end case, it'd be better to avoid IO contention, while low-end device wants to get more discard commands as much as possible. So, how about adding an option for this as a tunable point?

Agreed, how about adding a sysfs entry discard_tunning:
1: enabled, use 4k granularity, self-adapted speed based on real device free space. 0: disabled, use dcc->discard_granularity, fixed speed.

By default: enabled

Quoted 7 lines
Quoted 5 lines
Quoted 3 lines
Quoted 1 line

How do you think?

I don't think this is proper with a sysfs entry, since we already know the

You mean by storage capacity? <= 32GB means low-end?

Yes, that's current condition to judge it. If there is any other method, it'd be

That would be hard code...

Still I have not got any other method to do the judgment except capacity.

Thanks,

Quoted 275 lines

better to change it.

Quoted 270 lines

Thanks,

Quoted 267 lines

device type when mounting the partition. We won't require to change the policy on the fly. And, I still don't get to change the default.

Quoted 261 lines

Thanks,

Quoted 258 lines
Quoted 255 lines

IMO, in above cases, we'd better to issue discard with high speed for c), middle speed for b), and low speed for a).

How do you think?

Thanks,

Quoted 246 lines

Thanks,

Quoted 240 lines

Anyway, it comes out undiscarded block makes FTL GC be lower efficient and causing high lifetime overhead.

Let's tune discard speed as below:

a. adjust default issue interval:
original after
min_interval: 50ms 100ms
mid_interval: 500ms 1000ms
max_interval: 60000ms 10000ms

b. if last time we stop issuing discard due to IO interruption of user, let's reset all {min,mid,max}_interval to default one.

c. tune {min,mid,max}_interval with below calculation method:

base_interval = default_interval / 10;
total_interval = default_interval - base_interval; interval = base_interval + total_interval * (100 - dev_util) / 100;

For example:
min_interval (:100ms)
dev_util (%) interval (ms)
0 100
10 91
20 82
30 73
...
80 28
90 19
100 10

---
 fs/f2fs/f2fs.h    | 11 ++++----
 fs/f2fs/segment.c | 64 +++++++++++++++++++++++++++++++++++++----------
 fs/f2fs/segment.h |  9 +++++++
 fs/f2fs/super.c   |  2 +-
 4 files changed, 67 insertions(+), 19 deletions(-)
fs/f2fs/f2fs.h +6 -5
index 273ffdaf4891..a1dd2e1c3cb9 100644
@@ -185,10 +185,9 @@ enum {
 
 #define MAX_DISCARD_BLOCKS(sbi)		BLKS_PER_SEC(sbi)
 #define DEF_MAX_DISCARD_REQUEST		8	/* issue 8 discards per round */
-#define DEF_MIN_DISCARD_ISSUE_TIME	50	/* 50 ms, if exists */
-#define DEF_MID_DISCARD_ISSUE_TIME	500	/* 500 ms, if device busy */
-#define DEF_MAX_DISCARD_ISSUE_TIME	60000	/* 60 s, if no candidates */
-#define DEF_DISCARD_URGENT_UTIL		80	/* do more discard over 80% */
+#define DEF_MIN_DISCARD_ISSUE_TIME	100	/* 100 ms, if exists */
+#define DEF_MID_DISCARD_ISSUE_TIME	1000	/* 1000 ms, if device busy */
+#define DEF_MAX_DISCARD_ISSUE_TIME	10000	/* 10000 ms, if no candidates */
 #define DEF_CP_INTERVAL			60	/* 60 secs */
 #define DEF_IDLE_INTERVAL		5	/* 5 secs */
 
@@ -248,7 +247,8 @@ struct discard_entry {
 };
 
 /* default discard granularity of inner discard thread, unit: block count */
-#define DEFAULT_DISCARD_GRANULARITY		1
+#define MID_DISCARD_GRANULARITY			16
+#define MIN_DISCARD_GRANULARITY			1
 
 /* max discard pend list number */
 #define MAX_PLIST_NUM		512
@@ -330,6 +330,7 @@ struct discard_cmd_control {
 	atomic_t discard_cmd_cnt;		/* # of cached cmd count */
 	struct rb_root root;			/* root of discard rb-tree */
 	bool rbtree_check;			/* config for consistence check */
+	bool io_interrupted;			/* last state of io interrupted */
 };
 
 /* for the list of fsync inodes, used only during recovery */
fs/f2fs/segment.c +51 -13
index 8b52e8dfb12f..9564aaf1f27b 100644
@@ -968,6 +968,44 @@ static void __check_sit_bitmap(struct f2fs_sb_info *sbi,
 #endif
 }
 
+static void __adjust_discard_speed(unsigned int *interval,
+				unsigned int def_interval, int dev_util)
+{
+	unsigned int base_interval, total_interval;
+
+	base_interval = def_interval / 10;
+	total_interval = def_interval - base_interval;
+
+	/*
+	 * if def_interval = 100, adjusted interval should be in range of
+	 * [10, 100].
+	 */
+	*interval = base_interval + total_interval * (100 - dev_util) / 100;
+}
+
+static void __tune_discard_policy(struct f2fs_sb_info *sbi,
+					struct discard_policy *dpolicy)
+{
+	struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
+	int dev_util;
+
+	if (dcc->io_interrupted) {
+		dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
+		dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
+		dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
+		return;
+	}
+
+	dev_util = dev_utilization(sbi);
+
+	__adjust_discard_speed(&dpolicy->min_interval,
+				DEF_MIN_DISCARD_ISSUE_TIME, dev_util);
+	__adjust_discard_speed(&dpolicy->mid_interval,
+				DEF_MID_DISCARD_ISSUE_TIME, dev_util);
+	__adjust_discard_speed(&dpolicy->max_interval,
+				DEF_MAX_DISCARD_ISSUE_TIME, dev_util);
+}
+
 static void __init_discard_policy(struct f2fs_sb_info *sbi,
 				struct discard_policy *dpolicy,
 				int discard_type, unsigned int granularity)
@@ -982,20 +1020,11 @@ static void __init_discard_policy(struct f2fs_sb_info *sbi,
 	dpolicy->io_aware_gran = MAX_PLIST_NUM;
 
 	if (discard_type == DPOLICY_BG) {
-		dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
-		dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
 		dpolicy->io_aware = true;
 		dpolicy->sync = false;
 		dpolicy->ordered = true;
-		if (utilization(sbi) > DEF_DISCARD_URGENT_UTIL) {
-			dpolicy->granularity = 1;
-			dpolicy->max_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		}
+		__tune_discard_policy(sbi, dpolicy);
 	} else if (discard_type == DPOLICY_FORCE) {
-		dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
-		dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
 		dpolicy->io_aware = false;
 	} else if (discard_type == DPOLICY_FSTRIM) {
 		dpolicy->io_aware = false;
@@ -1353,6 +1382,8 @@ static unsigned int __issue_discard_cmd_orderly(struct f2fs_sb_info *sbi,
 	if (!issued && io_interrupted)
 		issued = -1;
 
+	dcc->io_interrupted = io_interrupted;
+
 	return issued;
 }
 
@@ -1370,7 +1401,7 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi,
 		if (i + 1 < dpolicy->granularity)
 			break;
 
-		if (i < DEFAULT_DISCARD_GRANULARITY && dpolicy->ordered)
+		if (i < MID_DISCARD_GRANULARITY && dpolicy->ordered)
 			return __issue_discard_cmd_orderly(sbi, dpolicy);
 
 		pend_list = &dcc->pend_list[i];
@@ -1407,6 +1438,8 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi,
 	if (!issued && io_interrupted)
 		issued = -1;
 
+	dcc->io_interrupted = io_interrupted;
+
 	return issued;
 }
 
@@ -1576,7 +1609,11 @@ static int issue_discard_thread(void *data)
 	struct f2fs_sb_info *sbi = data;
 	struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
 	wait_queue_head_t *q = &dcc->discard_wait_queue;
-	struct discard_policy dpolicy;
+	struct discard_policy dpolicy = {
+		.min_interval = DEF_MIN_DISCARD_ISSUE_TIME,
+		.mid_interval = DEF_MID_DISCARD_ISSUE_TIME,
+		.max_interval = DEF_MAX_DISCARD_ISSUE_TIME,
+	};
 	unsigned int wait_ms = DEF_MIN_DISCARD_ISSUE_TIME;
 	int issued;
 
@@ -1929,7 +1966,7 @@ static int create_discard_cmd_control(struct f2fs_sb_info *sbi)
 	if (!dcc)
 		return -ENOMEM;
 
-	dcc->discard_granularity = DEFAULT_DISCARD_GRANULARITY;
+	dcc->discard_granularity = MIN_DISCARD_GRANULARITY;
 	INIT_LIST_HEAD(&dcc->entry_list);
 	for (i = 0; i < MAX_PLIST_NUM; i++)
 		INIT_LIST_HEAD(&dcc->pend_list[i]);
@@ -1945,6 +1982,7 @@ static int create_discard_cmd_control(struct f2fs_sb_info *sbi)
 	dcc->next_pos = 0;
 	dcc->root = RB_ROOT;
 	dcc->rbtree_check = false;
+	dcc->io_interrupted = false;
 
 	init_waitqueue_head(&dcc->discard_wait_queue);
 	SM_I(sbi)->dcc_info = dcc;
fs/f2fs/segment.h +9 -0
index 422b0ceb1eaa..63b4da72cd34 100644
@@ -616,6 +616,15 @@ static inline int utilization(struct f2fs_sb_info *sbi)
 					sbi->user_block_count);
 }
 
+static inline int dev_utilization(struct f2fs_sb_info *sbi)
+{
+	unsigned int dev_blks;
+
+	dev_blks = valid_user_blocks(sbi) + SM_I(sbi)->dcc_info->undiscard_blks;
+	return div_u64((u64)dev_blks * 100,
+			MAIN_SEGS(sbi) << sbi->log_blocks_per_seg);
+}
+
 /*
  * Sometimes f2fs may be better to drop out-of-place update policy.
  * And, users can control the policy through sysfs entries.
fs/f2fs/super.c +1 -1
index b055f2ea77c5..55ed76daad23 100644
@@ -2862,7 +2862,7 @@ static void f2fs_tuning_parameters(struct f2fs_sb_info *sbi)
 	/* adjust parameters according to the volume size */
 	if (sm_i->main_segments <= SMALL_VOLUME_SEGMENTS) {
 		F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;
-		sm_i->dcc_info->discard_granularity = 1;
+		sm_i->dcc_info->discard_granularity = MIN_DISCARD_GRANULARITY;
 		sm_i->ipu_policy = 1 << F2FS_IPU_FORCE;
 	}
 
Signature · 1 line
2.18.0.rc1

.

.

.

.

maintainer
#10 lore raw

Re: [PATCH 2/2] f2fs: tune discard speed with storage usage rate

Quoted 48 lines · Chao Yu
Quoted 47 lines · Jaegeuk Kim
Quoted 46 lines · Chao Yu
Quoted 44 lines · Jaegeuk Kim
Quoted 34 lines · Chao Yu
Quoted 24 lines · Jaegeuk Kim
Quoted 23 lines · Chao Yu
Quoted 7 lines · Jaegeuk Kim
Quoted 3 lines · Chao Yu

Previously, discard speed was fixed mostly, and in high usage rate device, we will speed up issuing discard, but it doesn't make sense that in a non-full filesystem, we still issue discard with slow speed.

Could you please elaborate the problem in more detail? The speed depends on how many candidates?

undiscard blocks are all 4k granularity.
a) utility: filesystem: 20% + undiscard blocks: 20% = flash storage: 40%
b) utility: filesystem: 40% + undiscard blocks: 25% = flash storage: 65%
c) utility: filesystem: 60% + undiscard blocks: 30% = flash storage: 100%

1. for case c), we need to speed up issuing discard based on utilization of "filesystem + undiscard" instead of just utilization of filesystem.

(quoted diff) +0 -4
-		if (utilization(sbi) > DEF_DISCARD_URGENT_UTIL) {
-			dpolicy->granularity = 1;
-			dpolicy->max_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		}
Quoted 8 lines
Quoted 3 lines

2. If free space in storage touches therein threshold, performance will be very sensitive. In low-end storage, with high usage in space, even free space is reduced by 1%, performance will decrease a lot.

So, we may need to distinguish low-end vs. high-end storage. In high-end case, it'd be better to avoid IO contention, while low-end device wants to get more discard commands as much as possible. So, how about adding an option for this as a tunable point?

Quoted 7 lines

Agreed, how about adding a sysfs entry discard_tunning:
1: enabled, use 4k granularity, self-adapted speed based on real device free space. 0: disabled, use dcc->discard_granularity, fixed speed.

By default: enabled

How do you think?

I don't think this is proper with a sysfs entry, since we already know the

Quoted 7 lines
Quoted 3 lines
Quoted 1 line

You mean by storage capacity? <= 32GB means low-end?

Yes, that's current condition to judge it. If there is any other method, it'd be

That would be hard code...

Still I have not got any other method to do the judgment except capacity.

Maybe ufs or emmc?

Quoted 278 lines

Thanks,

Quoted 275 lines

better to change it.

Quoted 270 lines

Thanks,

Quoted 267 lines

device type when mounting the partition. We won't require to change the policy on the fly. And, I still don't get to change the default.

Quoted 261 lines

Thanks,

Quoted 258 lines
Quoted 255 lines

IMO, in above cases, we'd better to issue discard with high speed for c), middle speed for b), and low speed for a).

How do you think?

Thanks,

Quoted 246 lines

Thanks,

Quoted 240 lines

Anyway, it comes out undiscarded block makes FTL GC be lower efficient and causing high lifetime overhead.

Let's tune discard speed as below:

a. adjust default issue interval:
original after
min_interval: 50ms 100ms
mid_interval: 500ms 1000ms
max_interval: 60000ms 10000ms

b. if last time we stop issuing discard due to IO interruption of user, let's reset all {min,mid,max}_interval to default one.

c. tune {min,mid,max}_interval with below calculation method:

base_interval = default_interval / 10;
total_interval = default_interval - base_interval; interval = base_interval + total_interval * (100 - dev_util) / 100;

For example:
min_interval (:100ms)
dev_util (%) interval (ms)
0 100
10 91
20 82
30 73
...
80 28
90 19
100 10

---
 fs/f2fs/f2fs.h    | 11 ++++----
 fs/f2fs/segment.c | 64 +++++++++++++++++++++++++++++++++++++----------
 fs/f2fs/segment.h |  9 +++++++
 fs/f2fs/super.c   |  2 +-
 4 files changed, 67 insertions(+), 19 deletions(-)
fs/f2fs/f2fs.h +6 -5
index 273ffdaf4891..a1dd2e1c3cb9 100644
@@ -185,10 +185,9 @@ enum {
 
 #define MAX_DISCARD_BLOCKS(sbi)		BLKS_PER_SEC(sbi)
 #define DEF_MAX_DISCARD_REQUEST		8	/* issue 8 discards per round */
-#define DEF_MIN_DISCARD_ISSUE_TIME	50	/* 50 ms, if exists */
-#define DEF_MID_DISCARD_ISSUE_TIME	500	/* 500 ms, if device busy */
-#define DEF_MAX_DISCARD_ISSUE_TIME	60000	/* 60 s, if no candidates */
-#define DEF_DISCARD_URGENT_UTIL		80	/* do more discard over 80% */
+#define DEF_MIN_DISCARD_ISSUE_TIME	100	/* 100 ms, if exists */
+#define DEF_MID_DISCARD_ISSUE_TIME	1000	/* 1000 ms, if device busy */
+#define DEF_MAX_DISCARD_ISSUE_TIME	10000	/* 10000 ms, if no candidates */
 #define DEF_CP_INTERVAL			60	/* 60 secs */
 #define DEF_IDLE_INTERVAL		5	/* 5 secs */
 
@@ -248,7 +247,8 @@ struct discard_entry {
 };
 
 /* default discard granularity of inner discard thread, unit: block count */
-#define DEFAULT_DISCARD_GRANULARITY		1
+#define MID_DISCARD_GRANULARITY			16
+#define MIN_DISCARD_GRANULARITY			1
 
 /* max discard pend list number */
 #define MAX_PLIST_NUM		512
@@ -330,6 +330,7 @@ struct discard_cmd_control {
 	atomic_t discard_cmd_cnt;		/* # of cached cmd count */
 	struct rb_root root;			/* root of discard rb-tree */
 	bool rbtree_check;			/* config for consistence check */
+	bool io_interrupted;			/* last state of io interrupted */
 };
 
 /* for the list of fsync inodes, used only during recovery */
fs/f2fs/segment.c +51 -13
index 8b52e8dfb12f..9564aaf1f27b 100644
@@ -968,6 +968,44 @@ static void __check_sit_bitmap(struct f2fs_sb_info *sbi,
 #endif
 }
 
+static void __adjust_discard_speed(unsigned int *interval,
+				unsigned int def_interval, int dev_util)
+{
+	unsigned int base_interval, total_interval;
+
+	base_interval = def_interval / 10;
+	total_interval = def_interval - base_interval;
+
+	/*
+	 * if def_interval = 100, adjusted interval should be in range of
+	 * [10, 100].
+	 */
+	*interval = base_interval + total_interval * (100 - dev_util) / 100;
+}
+
+static void __tune_discard_policy(struct f2fs_sb_info *sbi,
+					struct discard_policy *dpolicy)
+{
+	struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
+	int dev_util;
+
+	if (dcc->io_interrupted) {
+		dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
+		dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
+		dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
+		return;
+	}
+
+	dev_util = dev_utilization(sbi);
+
+	__adjust_discard_speed(&dpolicy->min_interval,
+				DEF_MIN_DISCARD_ISSUE_TIME, dev_util);
+	__adjust_discard_speed(&dpolicy->mid_interval,
+				DEF_MID_DISCARD_ISSUE_TIME, dev_util);
+	__adjust_discard_speed(&dpolicy->max_interval,
+				DEF_MAX_DISCARD_ISSUE_TIME, dev_util);
+}
+
 static void __init_discard_policy(struct f2fs_sb_info *sbi,
 				struct discard_policy *dpolicy,
 				int discard_type, unsigned int granularity)
@@ -982,20 +1020,11 @@ static void __init_discard_policy(struct f2fs_sb_info *sbi,
 	dpolicy->io_aware_gran = MAX_PLIST_NUM;
 
 	if (discard_type == DPOLICY_BG) {
-		dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
-		dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
 		dpolicy->io_aware = true;
 		dpolicy->sync = false;
 		dpolicy->ordered = true;
-		if (utilization(sbi) > DEF_DISCARD_URGENT_UTIL) {
-			dpolicy->granularity = 1;
-			dpolicy->max_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		}
+		__tune_discard_policy(sbi, dpolicy);
 	} else if (discard_type == DPOLICY_FORCE) {
-		dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
-		dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
 		dpolicy->io_aware = false;
 	} else if (discard_type == DPOLICY_FSTRIM) {
 		dpolicy->io_aware = false;
@@ -1353,6 +1382,8 @@ static unsigned int __issue_discard_cmd_orderly(struct f2fs_sb_info *sbi,
 	if (!issued && io_interrupted)
 		issued = -1;
 
+	dcc->io_interrupted = io_interrupted;
+
 	return issued;
 }
 
@@ -1370,7 +1401,7 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi,
 		if (i + 1 < dpolicy->granularity)
 			break;
 
-		if (i < DEFAULT_DISCARD_GRANULARITY && dpolicy->ordered)
+		if (i < MID_DISCARD_GRANULARITY && dpolicy->ordered)
 			return __issue_discard_cmd_orderly(sbi, dpolicy);
 
 		pend_list = &dcc->pend_list[i];
@@ -1407,6 +1438,8 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi,
 	if (!issued && io_interrupted)
 		issued = -1;
 
+	dcc->io_interrupted = io_interrupted;
+
 	return issued;
 }
 
@@ -1576,7 +1609,11 @@ static int issue_discard_thread(void *data)
 	struct f2fs_sb_info *sbi = data;
 	struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
 	wait_queue_head_t *q = &dcc->discard_wait_queue;
-	struct discard_policy dpolicy;
+	struct discard_policy dpolicy = {
+		.min_interval = DEF_MIN_DISCARD_ISSUE_TIME,
+		.mid_interval = DEF_MID_DISCARD_ISSUE_TIME,
+		.max_interval = DEF_MAX_DISCARD_ISSUE_TIME,
+	};
 	unsigned int wait_ms = DEF_MIN_DISCARD_ISSUE_TIME;
 	int issued;
 
@@ -1929,7 +1966,7 @@ static int create_discard_cmd_control(struct f2fs_sb_info *sbi)
 	if (!dcc)
 		return -ENOMEM;
 
-	dcc->discard_granularity = DEFAULT_DISCARD_GRANULARITY;
+	dcc->discard_granularity = MIN_DISCARD_GRANULARITY;
 	INIT_LIST_HEAD(&dcc->entry_list);
 	for (i = 0; i < MAX_PLIST_NUM; i++)
 		INIT_LIST_HEAD(&dcc->pend_list[i]);
@@ -1945,6 +1982,7 @@ static int create_discard_cmd_control(struct f2fs_sb_info *sbi)
 	dcc->next_pos = 0;
 	dcc->root = RB_ROOT;
 	dcc->rbtree_check = false;
+	dcc->io_interrupted = false;
 
 	init_waitqueue_head(&dcc->discard_wait_queue);
 	SM_I(sbi)->dcc_info = dcc;
fs/f2fs/segment.h +9 -0
index 422b0ceb1eaa..63b4da72cd34 100644
@@ -616,6 +616,15 @@ static inline int utilization(struct f2fs_sb_info *sbi)
 					sbi->user_block_count);
 }
 
+static inline int dev_utilization(struct f2fs_sb_info *sbi)
+{
+	unsigned int dev_blks;
+
+	dev_blks = valid_user_blocks(sbi) + SM_I(sbi)->dcc_info->undiscard_blks;
+	return div_u64((u64)dev_blks * 100,
+			MAIN_SEGS(sbi) << sbi->log_blocks_per_seg);
+}
+
 /*
  * Sometimes f2fs may be better to drop out-of-place update policy.
  * And, users can control the policy through sysfs entries.
fs/f2fs/super.c +1 -1
index b055f2ea77c5..55ed76daad23 100644
@@ -2862,7 +2862,7 @@ static void f2fs_tuning_parameters(struct f2fs_sb_info *sbi)
 	/* adjust parameters according to the volume size */
 	if (sm_i->main_segments <= SMALL_VOLUME_SEGMENTS) {
 		F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;
-		sm_i->dcc_info->discard_granularity = 1;
+		sm_i->dcc_info->discard_granularity = MIN_DISCARD_GRANULARITY;
 		sm_i->ipu_policy = 1 << F2FS_IPU_FORCE;
 	}
 
Signature · 1 line
2.18.0.rc1

.

.

.

.

------------------------------------------------------------------------------
Check out the vibrant tech community on one of the world's most engaging tech sites, Slashdot.org! http://sdm.link/slashdot

author
#11 lore raw

Re: [PATCH 2/2] f2fs: tune discard speed with storage usage rate

Quoted 51 lines · Jaegeuk Kim
Quoted 50 lines · Chao Yu
Quoted 49 lines · Jaegeuk Kim
Quoted 47 lines · Chao Yu
Quoted 39 lines · Jaegeuk Kim
Quoted 38 lines · Chao Yu
Quoted 24 lines · Jaegeuk Kim
Quoted 23 lines · Chao Yu
Quoted 7 lines · Jaegeuk Kim
Quoted 3 lines · Chao Yu

Previously, discard speed was fixed mostly, and in high usage rate device, we will speed up issuing discard, but it doesn't make sense that in a non-full filesystem, we still issue discard with slow speed.

Could you please elaborate the problem in more detail? The speed depends on how many candidates?

undiscard blocks are all 4k granularity.
a) utility: filesystem: 20% + undiscard blocks: 20% = flash storage: 40%
b) utility: filesystem: 40% + undiscard blocks: 25% = flash storage: 65%
c) utility: filesystem: 60% + undiscard blocks: 30% = flash storage: 100%

1. for case c), we need to speed up issuing discard based on utilization of "filesystem + undiscard" instead of just utilization of filesystem.

(quoted diff) +0 -4
-		if (utilization(sbi) > DEF_DISCARD_URGENT_UTIL) {
-			dpolicy->granularity = 1;
-			dpolicy->max_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		}
Quoted 8 lines
Quoted 3 lines

2. If free space in storage touches therein threshold, performance will be very sensitive. In low-end storage, with high usage in space, even free space is reduced by 1%, performance will decrease a lot.

So, we may need to distinguish low-end vs. high-end storage. In high-end case, it'd be better to avoid IO contention, while low-end device wants to get more discard commands as much as possible. So, how about adding an option for this as a tunable point?

Agreed, how about adding a sysfs entry discard_tunning:
1: enabled, use 4k granularity, self-adapted speed based on real device free space. 0: disabled, use dcc->discard_granularity, fixed speed.

Quoted 5 lines
Quoted 3 lines

By default: enabled

How do you think?

I don't think this is proper with a sysfs entry, since we already know the

You mean by storage capacity? <= 32GB means low-end?

Quoted 7 lines
Quoted 5 lines
Quoted 1 line

Yes, that's current condition to judge it. If there is any other method, it'd be

That would be hard code...

Still I have not got any other method to do the judgment except capacity.

Maybe ufs or emmc?

Yeah, that's may be a good way.

I remember very initial version UFS has very poor discard performance, for that kind of storage, it will be not accurate?

Let me check whether there is a flag to distinguish ufs/emmc.

Thanks,

Quoted 282 lines
Quoted 279 lines

Thanks,

Quoted 275 lines

better to change it.

Quoted 270 lines

Thanks,

Quoted 267 lines

device type when mounting the partition. We won't require to change the policy on the fly. And, I still don't get to change the default.

Quoted 261 lines

Thanks,

Quoted 258 lines
Quoted 255 lines

IMO, in above cases, we'd better to issue discard with high speed for c), middle speed for b), and low speed for a).

How do you think?

Thanks,

Quoted 246 lines

Thanks,

Quoted 240 lines

Anyway, it comes out undiscarded block makes FTL GC be lower efficient and causing high lifetime overhead.

Let's tune discard speed as below:

a. adjust default issue interval:
original after
min_interval: 50ms 100ms
mid_interval: 500ms 1000ms
max_interval: 60000ms 10000ms

b. if last time we stop issuing discard due to IO interruption of user, let's reset all {min,mid,max}_interval to default one.

c. tune {min,mid,max}_interval with below calculation method:

base_interval = default_interval / 10;
total_interval = default_interval - base_interval; interval = base_interval + total_interval * (100 - dev_util) / 100;

For example:
min_interval (:100ms)
dev_util (%) interval (ms)
0 100
10 91
20 82
30 73
...
80 28
90 19
100 10

---
 fs/f2fs/f2fs.h    | 11 ++++----
 fs/f2fs/segment.c | 64 +++++++++++++++++++++++++++++++++++++----------
 fs/f2fs/segment.h |  9 +++++++
 fs/f2fs/super.c   |  2 +-
 4 files changed, 67 insertions(+), 19 deletions(-)
fs/f2fs/f2fs.h +6 -5
index 273ffdaf4891..a1dd2e1c3cb9 100644
@@ -185,10 +185,9 @@ enum {
 
 #define MAX_DISCARD_BLOCKS(sbi)		BLKS_PER_SEC(sbi)
 #define DEF_MAX_DISCARD_REQUEST		8	/* issue 8 discards per round */
-#define DEF_MIN_DISCARD_ISSUE_TIME	50	/* 50 ms, if exists */
-#define DEF_MID_DISCARD_ISSUE_TIME	500	/* 500 ms, if device busy */
-#define DEF_MAX_DISCARD_ISSUE_TIME	60000	/* 60 s, if no candidates */
-#define DEF_DISCARD_URGENT_UTIL		80	/* do more discard over 80% */
+#define DEF_MIN_DISCARD_ISSUE_TIME	100	/* 100 ms, if exists */
+#define DEF_MID_DISCARD_ISSUE_TIME	1000	/* 1000 ms, if device busy */
+#define DEF_MAX_DISCARD_ISSUE_TIME	10000	/* 10000 ms, if no candidates */
 #define DEF_CP_INTERVAL			60	/* 60 secs */
 #define DEF_IDLE_INTERVAL		5	/* 5 secs */
 
@@ -248,7 +247,8 @@ struct discard_entry {
 };
 
 /* default discard granularity of inner discard thread, unit: block count */
-#define DEFAULT_DISCARD_GRANULARITY		1
+#define MID_DISCARD_GRANULARITY			16
+#define MIN_DISCARD_GRANULARITY			1
 
 /* max discard pend list number */
 #define MAX_PLIST_NUM		512
@@ -330,6 +330,7 @@ struct discard_cmd_control {
 	atomic_t discard_cmd_cnt;		/* # of cached cmd count */
 	struct rb_root root;			/* root of discard rb-tree */
 	bool rbtree_check;			/* config for consistence check */
+	bool io_interrupted;			/* last state of io interrupted */
 };
 
 /* for the list of fsync inodes, used only during recovery */
fs/f2fs/segment.c +51 -13
index 8b52e8dfb12f..9564aaf1f27b 100644
@@ -968,6 +968,44 @@ static void __check_sit_bitmap(struct f2fs_sb_info *sbi,
 #endif
 }
 
+static void __adjust_discard_speed(unsigned int *interval,
+				unsigned int def_interval, int dev_util)
+{
+	unsigned int base_interval, total_interval;
+
+	base_interval = def_interval / 10;
+	total_interval = def_interval - base_interval;
+
+	/*
+	 * if def_interval = 100, adjusted interval should be in range of
+	 * [10, 100].
+	 */
+	*interval = base_interval + total_interval * (100 - dev_util) / 100;
+}
+
+static void __tune_discard_policy(struct f2fs_sb_info *sbi,
+					struct discard_policy *dpolicy)
+{
+	struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
+	int dev_util;
+
+	if (dcc->io_interrupted) {
+		dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
+		dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
+		dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
+		return;
+	}
+
+	dev_util = dev_utilization(sbi);
+
+	__adjust_discard_speed(&dpolicy->min_interval,
+				DEF_MIN_DISCARD_ISSUE_TIME, dev_util);
+	__adjust_discard_speed(&dpolicy->mid_interval,
+				DEF_MID_DISCARD_ISSUE_TIME, dev_util);
+	__adjust_discard_speed(&dpolicy->max_interval,
+				DEF_MAX_DISCARD_ISSUE_TIME, dev_util);
+}
+
 static void __init_discard_policy(struct f2fs_sb_info *sbi,
 				struct discard_policy *dpolicy,
 				int discard_type, unsigned int granularity)
@@ -982,20 +1020,11 @@ static void __init_discard_policy(struct f2fs_sb_info *sbi,
 	dpolicy->io_aware_gran = MAX_PLIST_NUM;
 
 	if (discard_type == DPOLICY_BG) {
-		dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
-		dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
 		dpolicy->io_aware = true;
 		dpolicy->sync = false;
 		dpolicy->ordered = true;
-		if (utilization(sbi) > DEF_DISCARD_URGENT_UTIL) {
-			dpolicy->granularity = 1;
-			dpolicy->max_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		}
+		__tune_discard_policy(sbi, dpolicy);
 	} else if (discard_type == DPOLICY_FORCE) {
-		dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-		dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
-		dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
 		dpolicy->io_aware = false;
 	} else if (discard_type == DPOLICY_FSTRIM) {
 		dpolicy->io_aware = false;
@@ -1353,6 +1382,8 @@ static unsigned int __issue_discard_cmd_orderly(struct f2fs_sb_info *sbi,
 	if (!issued && io_interrupted)
 		issued = -1;
 
+	dcc->io_interrupted = io_interrupted;
+
 	return issued;
 }
 
@@ -1370,7 +1401,7 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi,
 		if (i + 1 < dpolicy->granularity)
 			break;
 
-		if (i < DEFAULT_DISCARD_GRANULARITY && dpolicy->ordered)
+		if (i < MID_DISCARD_GRANULARITY && dpolicy->ordered)
 			return __issue_discard_cmd_orderly(sbi, dpolicy);
 
 		pend_list = &dcc->pend_list[i];
@@ -1407,6 +1438,8 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi,
 	if (!issued && io_interrupted)
 		issued = -1;
 
+	dcc->io_interrupted = io_interrupted;
+
 	return issued;
 }
 
@@ -1576,7 +1609,11 @@ static int issue_discard_thread(void *data)
 	struct f2fs_sb_info *sbi = data;
 	struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
 	wait_queue_head_t *q = &dcc->discard_wait_queue;
-	struct discard_policy dpolicy;
+	struct discard_policy dpolicy = {
+		.min_interval = DEF_MIN_DISCARD_ISSUE_TIME,
+		.mid_interval = DEF_MID_DISCARD_ISSUE_TIME,
+		.max_interval = DEF_MAX_DISCARD_ISSUE_TIME,
+	};
 	unsigned int wait_ms = DEF_MIN_DISCARD_ISSUE_TIME;
 	int issued;
 
@@ -1929,7 +1966,7 @@ static int create_discard_cmd_control(struct f2fs_sb_info *sbi)
 	if (!dcc)
 		return -ENOMEM;
 
-	dcc->discard_granularity = DEFAULT_DISCARD_GRANULARITY;
+	dcc->discard_granularity = MIN_DISCARD_GRANULARITY;
 	INIT_LIST_HEAD(&dcc->entry_list);
 	for (i = 0; i < MAX_PLIST_NUM; i++)
 		INIT_LIST_HEAD(&dcc->pend_list[i]);
@@ -1945,6 +1982,7 @@ static int create_discard_cmd_control(struct f2fs_sb_info *sbi)
 	dcc->next_pos = 0;
 	dcc->root = RB_ROOT;
 	dcc->rbtree_check = false;
+	dcc->io_interrupted = false;
 
 	init_waitqueue_head(&dcc->discard_wait_queue);
 	SM_I(sbi)->dcc_info = dcc;
fs/f2fs/segment.h +9 -0
index 422b0ceb1eaa..63b4da72cd34 100644
@@ -616,6 +616,15 @@ static inline int utilization(struct f2fs_sb_info *sbi)
 					sbi->user_block_count);
 }
 
+static inline int dev_utilization(struct f2fs_sb_info *sbi)
+{
+	unsigned int dev_blks;
+
+	dev_blks = valid_user_blocks(sbi) + SM_I(sbi)->dcc_info->undiscard_blks;
+	return div_u64((u64)dev_blks * 100,
+			MAIN_SEGS(sbi) << sbi->log_blocks_per_seg);
+}
+
 /*
  * Sometimes f2fs may be better to drop out-of-place update policy.
  * And, users can control the policy through sysfs entries.
fs/f2fs/super.c +1 -1
index b055f2ea77c5..55ed76daad23 100644
@@ -2862,7 +2862,7 @@ static void f2fs_tuning_parameters(struct f2fs_sb_info *sbi)
 	/* adjust parameters according to the volume size */
 	if (sm_i->main_segments <= SMALL_VOLUME_SEGMENTS) {
 		F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;
-		sm_i->dcc_info->discard_granularity = 1;
+		sm_i->dcc_info->discard_granularity = MIN_DISCARD_GRANULARITY;
 		sm_i->ipu_policy = 1 << F2FS_IPU_FORCE;
 	}
 
Signature · 1 line
2.18.0.rc1

.

.

.

.

.

A message that is not in the archive (sent off-list or not yet received): CAD14+f1MoAjEuXwGSmL3=0ROX_f=9jZVmvNsU9gnTP=UNxsTrg@mail.gmail.com

maintainer
#13 lore raw

Re: [f2fs-dev] [PATCH 2/2] f2fs: tune discard speed with storage usage rate

Quoted 5 lines · Ju Hyung Park

btrfs also distinguishes high/low end SSDs with mount option "ssd" and "ssd_spread".
I believe there is no implementation inside btrfs to do it automatically.

Providing users an option with a well made documentation is acceptable imo.

Yeah, I was thinking about this as well. How about adding "-o disk=%s" where %s can be ufs/emmc/ssd/low_ssd/nvme/...?
And, we also can decide the device type automatically w/ kmsg by default.

Quoted 435 lines

And I personally think, if the default goes to a dynamically deciding method, it should tell it to kmsg.

Thanks,

Quoted 427 lines · Chao Yu
Quoted 10 lines · Jaegeuk Kim
Quoted 9 lines · Chao Yu
Quoted 8 lines · Jaegeuk Kim
Quoted 7 lines · Chao Yu
Quoted 6 lines · Jaegeuk Kim
Quoted 5 lines · Chao Yu
Quoted 4 lines · Jaegeuk Kim
Quoted 3 lines · Chao Yu
Quoted 2 lines · Jaegeuk Kim
Quoted 1 line · Chao Yu

Previously, discard speed was fixed mostly, and in high usage

rate

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

device, we will speed up issuing discard, but it doesn't make

sense

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

that in a non-full filesystem, we still issue discard with slow

speed.

Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines

Could you please elaborate the problem in more detail? The speed

depends

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 1 line

on how many candidates?

undiscard blocks are all 4k granularity.
a) utility: filesystem: 20% + undiscard blocks: 20% = flash

storage: 40%

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

b) utility: filesystem: 40% + undiscard blocks: 25% = flash

storage: 65%

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

c) utility: filesystem: 60% + undiscard blocks: 30% = flash

storage: 100%

Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines

1. for case c), we need to speed up issuing discard based on

utilization of

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

"filesystem + undiscard" instead of just utilization of

filesystem.

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines

Review

Quoted 4 lines
(quoted diff) +0 -3
-              if (utilization(sbi) > DEF_DISCARD_URGENT_UTIL) {
-                      dpolicy->granularity = 1;
-                      dpolicy->max_interval =

DEF_MIN_DISCARD_ISSUE_TIME;

Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines

- }

2. If free space in storage touches therein threshold,

performance will be very

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

sensitive. In low-end storage, with high usage in space, even

free space is

Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 1 line

reduced by 1%, performance will decrease a lot.

So, we may need to distinguish low-end vs. high-end storage. In

high-end case,

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

it'd be better to avoid IO contention, while low-end device wants

to get more

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

discard commands as much as possible. So, how about adding an

option for this

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 1 line

as a tunable point?

Agreed, how about adding a sysfs entry discard_tunning:
1: enabled, use 4k granularity, self-adapted speed based on real

device free space.

Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 5 lines

0: disabled, use dcc->discard_granularity, fixed speed.

By default: enabled

How do you think?

I don't think this is proper with a sysfs entry, since we already

know the

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 2 lines

You mean by storage capacity? <= 32GB means low-end?

Yes, that's current condition to judge it. If there is any other

method, it'd be

Quoted 4 lines
Quoted 4 lines

That would be hard code...

Still I have not got any other method to do the judgment except

capacity.

Quoted 2 lines

Maybe ufs or emmc?

Yeah, that's may be a good way.

I remember very initial version UFS has very poor discard performance, for that
kind of storage, it will be not accurate?

Let me check whether there is a flag to distinguish ufs/emmc.

Thanks,

Quoted 10 lines
Quoted 10 lines

Thanks,

Quoted 6 lines

better to change it.

Quoted 4 lines

Thanks,

Quoted 1 line

device type when mounting the partition. We won't require to change

the policy

Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines

on the fly. And, I still don't get to change the default.

Quoted 6 lines

Thanks,

Quoted 3 lines
Quoted 3 lines

IMO, in above cases, we'd better to issue discard with high speed

for c), middle

Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines

speed for b), and low speed for a).

How do you think?

Thanks,

Quoted 5 lines

Thanks,

Quoted 2 lines

Anyway, it comes out undiscarded block makes FTL GC be lower

efficient

Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines

and causing high lifetime overhead.

Let's tune discard speed as below:

a. adjust default issue interval:
original after

min_interval:        50ms            100ms
mid_interval:        500ms           1000ms
max_interval:        60000ms         10000ms

b. if last time we stop issuing discard due to IO interruption

of user,

Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines

let's reset all {min,mid,max}_interval to default one.

c. tune {min,mid,max}_interval with below calculation method:

base_interval = default_interval / 10; total_interval = default_interval - base_interval; interval = base_interval + total_interval * (100 - dev_util) /

100;

Quoted 13 lines
Quoted 13 lines
Quoted 13 lines
Quoted 13 lines
Quoted 13 lines
Quoted 13 lines
Quoted 13 lines
Quoted 13 lines
Quoted 13 lines
Quoted 13 lines

For example:
min_interval (:100ms)
dev_util (%) interval (ms)

0            100
10           91
20           82
30           73
...
80           28
90           19
100          10
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
---
 fs/f2fs/f2fs.h    | 11 ++++----
 fs/f2fs/segment.c | 64

+++++++++++++++++++++++++++++++++++++----------

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
 fs/f2fs/segment.h |  9 +++++++
 fs/f2fs/super.c   |  2 +-
 4 files changed, 67 insertions(+), 19 deletions(-)
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines

fs/f2fs/f2fs.h enum { · line 187

Quoted 8 lines
fs/f2fs/f2fs.h +0 -0
index 273ffdaf4891..a1dd2e1c3cb9 100644
@@ -185,10 +185,9 @@ enum {
 
 #define MAX_DISCARD_BLOCKS(sbi)             BLKS_PER_SEC(sbi)
 #define DEF_MAX_DISCARD_REQUEST             8       /* issue 8

discards per round */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

fs/f2fs/f2fs.h enum { · line 188

Quoted 1 line
fs/f2fs/f2fs.h +0 -1
-#define DEF_MIN_DISCARD_ISSUE_TIME  50      /* 50 ms, if

exists */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

fs/f2fs/f2fs.h enum { · line 189

Quoted 1 line
fs/f2fs/f2fs.h +0 -1
-#define DEF_MID_DISCARD_ISSUE_TIME  500     /* 500 ms, if

device busy */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

fs/f2fs/f2fs.h enum { · line 190

Quoted 1 line
fs/f2fs/f2fs.h +0 -1
-#define DEF_MAX_DISCARD_ISSUE_TIME  60000   /* 60 s, if no

candidates */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

fs/f2fs/f2fs.h enum { · line 191

Quoted 1 line
fs/f2fs/f2fs.h +0 -1
-#define DEF_DISCARD_URGENT_UTIL             80      /* do more

discard over 80% */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

fs/f2fs/f2fs.h enum { · line 188

Quoted 1 line
fs/f2fs/f2fs.h +1 -0
+#define DEF_MIN_DISCARD_ISSUE_TIME  100     /* 100 ms, if

exists */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

fs/f2fs/f2fs.h enum { · line 189

Quoted 1 line
fs/f2fs/f2fs.h +1 -0
+#define DEF_MID_DISCARD_ISSUE_TIME  1000    /* 1000 ms, if

device busy */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

fs/f2fs/f2fs.h enum { · line 190

Quoted 1 line
fs/f2fs/f2fs.h +1 -0
+#define DEF_MAX_DISCARD_ISSUE_TIME  10000   /* 10000 ms, if no

candidates */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

fs/f2fs/f2fs.h enum { · line 191

Quoted 1 line
fs/f2fs/f2fs.h +0 -0
 #define DEF_CP_INTERVAL                     60      /* 60 secs

*/

Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines

fs/f2fs/f2fs.h struct discard_entry { · line 249

Quoted 6 lines
fs/f2fs/f2fs.h +0 -0
 #define DEF_IDLE_INTERVAL           5       /* 5 secs */
 
@@ -248,7 +247,8 @@ struct discard_entry {
 };
 
 /* default discard granularity of inner discard thread, unit:

block count */

Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines

fs/f2fs/f2fs.h struct discard_cmd_control { · line 330

Quoted 8 lines
fs/f2fs/f2fs.h +2 -1
-#define DEFAULT_DISCARD_GRANULARITY         1
+#define MID_DISCARD_GRANULARITY                     16
+#define MIN_DISCARD_GRANULARITY                     1
 
 /* max discard pend list number */
 #define MAX_PLIST_NUM               512
@@ -330,6 +330,7 @@ struct discard_cmd_control {
     atomic_t discard_cmd_cnt;               /* # of cached cmd

count */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

fs/f2fs/f2fs.h struct discard_cmd_control { · line 331

Quoted 1 line
fs/f2fs/f2fs.h +0 -0
     struct rb_root root;                    /* root of discard

rb-tree */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

fs/f2fs/f2fs.h struct discard_cmd_control { · line 332

Quoted 1 line
fs/f2fs/f2fs.h +0 -0
     bool rbtree_check;                      /* config for

consistence check */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

fs/f2fs/f2fs.h struct discard_cmd_control { · line 333

Quoted 1 line
fs/f2fs/f2fs.h +1 -0
+    bool io_interrupted;                    /* last state of

io interrupted */

Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines

fs/f2fs/segment.c static void __check_sit_bitmap(struct

Quoted 8 lines
fs/f2fs/f2fs.h +0 -0
 };
 
 /* for the list of fsync inodes, used only during recovery */
fs/f2fs/segment.c +0 -0
index 8b52e8dfb12f..9564aaf1f27b 100644
@@ -968,6 +968,44 @@ static void __check_sit_bitmap(struct

f2fs_sb_info *sbi,

Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines

fs/f2fs/segment.c static void __check_sit_bitmap(struct · line 972

Quoted 5 lines
fs/f2fs/segment.c +2 -0
 #endif
 }
 
+static void __adjust_discard_speed(unsigned int *interval,
+                            unsigned int def_interval, int

dev_util)

Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines

fs/f2fs/segment.c static void __check_sit_bitmap(struct · line 980

Quoted 8 lines
fs/f2fs/segment.c +8 -0
+{
+    unsigned int base_interval, total_interval;
+
+    base_interval = def_interval / 10;
+    total_interval = def_interval - base_interval;
+
+    /*
+     * if def_interval = 100, adjusted interval should be in

range of

Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines

fs/f2fs/segment.c static void __check_sit_bitmap(struct · line 983

Quoted 3 lines
fs/f2fs/segment.c +3 -0
+     * [10, 100].
+     */
+    *interval = base_interval + total_interval * (100 -

dev_util) / 100;

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines

fs/f2fs/segment.c static void __check_sit_bitmap(struct · line 987

Quoted 4 lines
fs/f2fs/segment.c +4 -0
+}
+
+static void __tune_discard_policy(struct f2fs_sb_info *sbi,
+                                    struct discard_policy

*dpolicy)

Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
fs/f2fs/segment.c +7 -0
+{
+    struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
+    int dev_util;
+
+    if (dcc->io_interrupted) {
+            dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
+            dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines

fs/f2fs/segment.c static void __check_sit_bitmap(struct · line 1002

Quoted 8 lines
fs/f2fs/segment.c +8 -0
+            dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
+            return;
+    }
+
+    dev_util = dev_utilization(sbi);
+
+    __adjust_discard_speed(&dpolicy->min_interval,
+                            DEF_MIN_DISCARD_ISSUE_TIME,

dev_util);

Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines

fs/f2fs/segment.c static void __check_sit_bitmap(struct · line 1004

Quoted 2 lines
fs/f2fs/segment.c +2 -0
+    __adjust_discard_speed(&dpolicy->mid_interval,
+                            DEF_MID_DISCARD_ISSUE_TIME,

dev_util);

Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines

fs/f2fs/segment.c static void __check_sit_bitmap(struct · line 1006

Quoted 2 lines
fs/f2fs/segment.c +2 -0
+    __adjust_discard_speed(&dpolicy->max_interval,
+                            DEF_MAX_DISCARD_ISSUE_TIME,

dev_util);

Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines

fs/f2fs/segment.c static void __check_sit_bitmap(struct · line 1011

Quoted 5 lines
fs/f2fs/segment.c +2 -0
+}
+
 static void __init_discard_policy(struct f2fs_sb_info *sbi,
                             struct discard_policy *dpolicy,
                             int discard_type, unsigned int

granularity)

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

fs/f2fs/segment.c static void __init_discard_policy(struct

Quoted 1 line
fs/f2fs/segment.c +0 -0
@@ -982,20 +1020,11 @@ static void __init_discard_policy(struct

f2fs_sb_info *sbi,

Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines

fs/f2fs/segment.c static void __init_discard_policy(struct · line 993

Quoted 12 lines
fs/f2fs/segment.c +0 -6
     dpolicy->io_aware_gran = MAX_PLIST_NUM;
 
     if (discard_type == DPOLICY_BG) {
-            dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-            dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
-            dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
             dpolicy->io_aware = true;
             dpolicy->sync = false;
             dpolicy->ordered = true;
-            if (utilization(sbi) > DEF_DISCARD_URGENT_UTIL) {
-                    dpolicy->granularity = 1;
-                    dpolicy->max_interval =

DEF_MIN_DISCARD_ISSUE_TIME;

Quoted 10 lines
Quoted 10 lines
Quoted 10 lines
Quoted 10 lines
Quoted 10 lines
Quoted 10 lines
Quoted 10 lines
Quoted 10 lines
Quoted 10 lines

fs/f2fs/segment.c static unsigned int

Quoted 10 lines
fs/f2fs/segment.c +1 -4
-            }
+            __tune_discard_policy(sbi, dpolicy);
     } else if (discard_type == DPOLICY_FORCE) {
-            dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
-            dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
-            dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
             dpolicy->io_aware = false;
     } else if (discard_type == DPOLICY_FSTRIM) {
             dpolicy->io_aware = false;
@@ -1353,6 +1382,8 @@ static unsigned int

__issue_discard_cmd_orderly(struct f2fs_sb_info *sbi,

Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines

fs/f2fs/segment.c static int __issue_discard_cmd(struct

Quoted 9 lines
fs/f2fs/segment.c +2 -0
     if (!issued && io_interrupted)
             issued = -1;
 
+    dcc->io_interrupted = io_interrupted;
+
     return issued;
 }
 
@@ -1370,7 +1401,7 @@ static int __issue_discard_cmd(struct

f2fs_sb_info *sbi,

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines

fs/f2fs/segment.c static int __issue_discard_cmd(struct · line 1373

Quoted 4 lines
fs/f2fs/segment.c +0 -1
             if (i + 1 < dpolicy->granularity)
                     break;
 
-            if (i < DEFAULT_DISCARD_GRANULARITY &&

dpolicy->ordered)

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

fs/f2fs/segment.c static int __issue_discard_cmd(struct · line 1404

Quoted 1 line
fs/f2fs/segment.c +1 -0
+            if (i < MID_DISCARD_GRANULARITY &&

dpolicy->ordered)

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

fs/f2fs/segment.c static int __issue_discard_cmd(struct · line 1405

Quoted 1 line
fs/f2fs/segment.c +0 -0
                     return __issue_discard_cmd_orderly(sbi,

dpolicy);

Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines

fs/f2fs/segment.c static int __issue_discard_cmd(struct

Quoted 3 lines
fs/f2fs/segment.c +0 -0
             pend_list = &dcc->pend_list[i];
@@ -1407,6 +1438,8 @@ static int __issue_discard_cmd(struct

f2fs_sb_info *sbi,

Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines

fs/f2fs/segment.c static int issue_discard_thread(void

Quoted 9 lines
fs/f2fs/segment.c +2 -0
     if (!issued && io_interrupted)
             issued = -1;
 
+    dcc->io_interrupted = io_interrupted;
+
     return issued;
 }
 
@@ -1576,7 +1609,11 @@ static int issue_discard_thread(void

*data)

Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
fs/f2fs/segment.c +5 -1
     struct f2fs_sb_info *sbi = data;
     struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
     wait_queue_head_t *q = &dcc->discard_wait_queue;
-    struct discard_policy dpolicy;
+    struct discard_policy dpolicy = {
+            .min_interval = DEF_MIN_DISCARD_ISSUE_TIME,
+            .mid_interval = DEF_MID_DISCARD_ISSUE_TIME,
+            .max_interval = DEF_MAX_DISCARD_ISSUE_TIME,
+    };
     unsigned int wait_ms = DEF_MIN_DISCARD_ISSUE_TIME;
     int issued;
 
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

fs/f2fs/segment.c static int

Quoted 1 line
fs/f2fs/segment.c +0 -0
@@ -1929,7 +1966,7 @@ static int

create_discard_cmd_control(struct f2fs_sb_info *sbi)

Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines

fs/f2fs/segment.c static int

Quoted 9 lines
fs/f2fs/segment.c +1 -1
     if (!dcc)
             return -ENOMEM;
 
-    dcc->discard_granularity = DEFAULT_DISCARD_GRANULARITY;
+    dcc->discard_granularity = MIN_DISCARD_GRANULARITY;
     INIT_LIST_HEAD(&dcc->entry_list);
     for (i = 0; i < MAX_PLIST_NUM; i++)
             INIT_LIST_HEAD(&dcc->pend_list[i]);
@@ -1945,6 +1982,7 @@ static int

create_discard_cmd_control(struct f2fs_sb_info *sbi)

Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
fs/f2fs/segment.c +1 -0
     dcc->next_pos = 0;
     dcc->root = RB_ROOT;
     dcc->rbtree_check = false;
+    dcc->io_interrupted = false;
 
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines

fs/f2fs/segment.h static inline int utilization(struct

Quoted 7 lines
fs/f2fs/segment.c +0 -0
     init_waitqueue_head(&dcc->discard_wait_queue);
     SM_I(sbi)->dcc_info = dcc;
fs/f2fs/segment.h +0 -0
index 422b0ceb1eaa..63b4da72cd34 100644
@@ -616,6 +616,15 @@ static inline int utilization(struct

f2fs_sb_info *sbi)

Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines

fs/f2fs/segment.h static inline int utilization(struct · line 623

Quoted 8 lines
fs/f2fs/segment.h +5 -0
                                     sbi->user_block_count);
 }
 
+static inline int dev_utilization(struct f2fs_sb_info *sbi)
+{
+    unsigned int dev_blks;
+
+    dev_blks = valid_user_blocks(sbi) +

SM_I(sbi)->dcc_info->undiscard_blks;

Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines

fs/f2fs/segment.h static inline int utilization(struct · line 629

Quoted 6 lines
fs/f2fs/segment.h +4 -0
+    return div_u64((u64)dev_blks * 100,
+                    MAIN_SEGS(sbi) << sbi->log_blocks_per_seg);
+}
+
 /*
  * Sometimes f2fs may be better to drop out-of-place update

policy.

Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines

fs/f2fs/super.c static void f2fs_tuning_parameters(struct

Quoted 6 lines
fs/f2fs/segment.h +0 -0
  * And, users can control the policy through sysfs entries.
fs/f2fs/super.c +0 -0
index b055f2ea77c5..55ed76daad23 100644
@@ -2862,7 +2862,7 @@ static void f2fs_tuning_parameters(struct

f2fs_sb_info *sbi)

Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines

fs/f2fs/super.c static void f2fs_tuning_parameters(struct · line 2865

Quoted 5 lines
fs/f2fs/super.c +1 -1
     /* adjust parameters according to the volume size */
     if (sm_i->main_segments <= SMALL_VOLUME_SEGMENTS) {
             F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;
-            sm_i->dcc_info->discard_granularity = 1;
+            sm_i->dcc_info->discard_granularity =

MIN_DISCARD_GRANULARITY;

Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 11 lines
Quoted 11 lines
Quoted 8 lines
Quoted 8 lines
Quoted 5 lines
fs/f2fs/super.c +0 -1
             sm_i->ipu_policy = 1 << F2FS_IPU_FORCE;
     }
 
--

2.18.0.rc1

.

.

Quoted 8 lines
Quoted 5 lines
Quoted 5 lines
Quoted 2 lines
Quoted 2 lines

.

.

.

------------------------------------------------------------------------------
Check out the vibrant tech community on one of the world's most engaging tech sites, Slashdot.org! http://sdm.link/slashdot
_______________________________________________
Linux-f2fs-devel mailing list [email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel

------------------------------------------------------------------------------
Check out the vibrant tech community on one of the world's most engaging tech sites, Slashdot.org! http://sdm.link/slashdot

author
#14 lore raw

Re: [f2fs-dev] [PATCH 2/2] f2fs: tune discard speed with storage usage rate

Quoted 9 lines · Jaegeuk Kim
Quoted 5 lines · Ju Hyung Park

btrfs also distinguishes high/low end SSDs with mount option "ssd" and "ssd_spread".
I believe there is no implementation inside btrfs to do it automatically.

Providing users an option with a well made documentation is acceptable imo.

Yeah, I was thinking about this as well. How about adding "-o disk=%s" where %s can be ufs/emmc/ssd/low_ssd/nvme/...?

Agreed,

Quoted 1 line

And, we also can decide the device type automatically w/ kmsg by default.

You mean by scanning kmsg to see the device type?

Thanks,

Quoted 439 lines
Quoted 436 lines

And I personally think, if the default goes to a dynamically deciding method, it should tell it to kmsg.

Thanks,

Quoted 427 lines · Chao Yu
Quoted 10 lines · Jaegeuk Kim
Quoted 9 lines · Chao Yu
Quoted 8 lines · Jaegeuk Kim
Quoted 7 lines · Chao Yu
Quoted 6 lines · Jaegeuk Kim
Quoted 5 lines · Chao Yu
Quoted 4 lines · Jaegeuk Kim
Quoted 3 lines · Chao Yu
Quoted 2 lines · Jaegeuk Kim
Quoted 1 line · Chao Yu

Previously, discard speed was fixed mostly, and in high usage

rate

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

device, we will speed up issuing discard, but it doesn't make

sense

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

that in a non-full filesystem, we still issue discard with slow

speed.

Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines

Could you please elaborate the problem in more detail? The speed

depends

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 1 line

on how many candidates?

undiscard blocks are all 4k granularity.
a) utility: filesystem: 20% + undiscard blocks: 20% = flash

storage: 40%

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

b) utility: filesystem: 40% + undiscard blocks: 25% = flash

storage: 65%

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

c) utility: filesystem: 60% + undiscard blocks: 30% = flash

storage: 100%

Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines

1. for case c), we need to speed up issuing discard based on

utilization of

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

"filesystem + undiscard" instead of just utilization of

filesystem.

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines

Review

Quoted 4 lines
(quoted diff) +0 -3
-              if (utilization(sbi) > DEF_DISCARD_URGENT_UTIL) {
-                      dpolicy->granularity = 1;
-                      dpolicy->max_interval =

DEF_MIN_DISCARD_ISSUE_TIME;

Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines

- }

2. If free space in storage touches therein threshold,

performance will be very

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

sensitive. In low-end storage, with high usage in space, even

free space is

Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 1 line

reduced by 1%, performance will decrease a lot.

So, we may need to distinguish low-end vs. high-end storage. In

high-end case,

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

it'd be better to avoid IO contention, while low-end device wants

to get more

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

discard commands as much as possible. So, how about adding an

option for this

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 1 line

as a tunable point?

Agreed, how about adding a sysfs entry discard_tunning:
1: enabled, use 4k granularity, self-adapted speed based on real

device free space.

Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 5 lines

0: disabled, use dcc->discard_granularity, fixed speed.

By default: enabled

How do you think?

I don't think this is proper with a sysfs entry, since we already

know the

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 2 lines

You mean by storage capacity? <= 32GB means low-end?

Yes, that's current condition to judge it. If there is any other

method, it'd be

Quoted 4 lines
Quoted 4 lines

That would be hard code...

Still I have not got any other method to do the judgment except

capacity.

Quoted 2 lines

Maybe ufs or emmc?

Yeah, that's may be a good way.

I remember very initial version UFS has very poor discard performance, for that
kind of storage, it will be not accurate?

Let me check whether there is a flag to distinguish ufs/emmc.

Thanks,

Quoted 10 lines
Quoted 10 lines

Thanks,

Quoted 6 lines

better to change it.

Quoted 4 lines

Thanks,

Quoted 1 line

device type when mounting the partition. We won't require to change

the policy

Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines

on the fly. And, I still don't get to change the default.

Quoted 6 lines

Thanks,

Quoted 3 lines
Quoted 3 lines

IMO, in above cases, we'd better to issue discard with high speed

for c), middle

Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines

speed for b), and low speed for a).

How do you think?

Thanks,

Quoted 5 lines

Thanks,

Quoted 2 lines

Anyway, it comes out undiscarded block makes FTL GC be lower

efficient

Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines

and causing high lifetime overhead.

Let's tune discard speed as below:

a. adjust default issue interval:
original after
min_interval: 50ms 100ms
mid_interval: 500ms 1000ms
max_interval: 60000ms 10000ms

b. if last time we stop issuing discard due to IO interruption

of user,

Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines

let's reset all {min,mid,max}_interval to default one.

c. tune {min,mid,max}_interval with below calculation method:

base_interval = default_interval / 10;
total_interval = default_interval - base_interval;
interval = base_interval + total_interval * (100 - dev_util) /

100;

Quoted 13 lines
Quoted 13 lines
Quoted 13 lines
Quoted 13 lines
Quoted 13 lines
Quoted 13 lines
Quoted 13 lines
Quoted 13 lines
Quoted 13 lines
Quoted 13 lines

For example:
min_interval (:100ms)
dev_util (%) interval (ms)
0 100
10 91
20 82
30 73
...
80 28
90 19
100 10

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines

Signed-off-by: Chao Yu <[email protected]>
---
fs/f2fs/f2fs.h | 11 ++++----
fs/f2fs/segment.c | 64

+++++++++++++++++++++++++++++++++++++----------

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines

fs/f2fs/segment.h | 9 +++++++
fs/f2fs/super.c | 2 +-
4 files changed, 67 insertions(+), 19 deletions(-)

Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 273ffdaf4891..a1dd2e1c3cb9 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -185,10 +185,9 @@ enum {

#define MAX_DISCARD_BLOCKS(sbi) BLKS_PER_SEC(sbi)
#define DEF_MAX_DISCARD_REQUEST 8 /* issue 8

discards per round */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

-#define DEF_MIN_DISCARD_ISSUE_TIME 50 /* 50 ms, if

exists */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

-#define DEF_MID_DISCARD_ISSUE_TIME 500 /* 500 ms, if

device busy */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

-#define DEF_MAX_DISCARD_ISSUE_TIME 60000 /* 60 s, if no

candidates */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

-#define DEF_DISCARD_URGENT_UTIL 80 /* do more

discard over 80% */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

+#define DEF_MIN_DISCARD_ISSUE_TIME 100 /* 100 ms, if

exists */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

+#define DEF_MID_DISCARD_ISSUE_TIME 1000 /* 1000 ms, if

device busy */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

+#define DEF_MAX_DISCARD_ISSUE_TIME 10000 /* 10000 ms, if no

candidates */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

#define DEF_CP_INTERVAL 60 /* 60 secs

*/

Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines

#define DEF_IDLE_INTERVAL 5 /* 5 secs */

@@ -248,7 +247,8 @@ struct discard_entry {
};

/* default discard granularity of inner discard thread, unit:

block count */

Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines

-#define DEFAULT_DISCARD_GRANULARITY 1
+#define MID_DISCARD_GRANULARITY 16
+#define MIN_DISCARD_GRANULARITY 1

/* max discard pend list number */
#define MAX_PLIST_NUM 512
@@ -330,6 +330,7 @@ struct discard_cmd_control {
atomic_t discard_cmd_cnt; /* # of cached cmd

count */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

struct rb_root root; /* root of discard

rb-tree */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

bool rbtree_check; /* config for

consistence check */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

+ bool io_interrupted; /* last state of

io interrupted */

Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines

};

/* for the list of fsync inodes, used only during recovery */
diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 8b52e8dfb12f..9564aaf1f27b 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -968,6 +968,44 @@ static void __check_sit_bitmap(struct

f2fs_sb_info *sbi,

Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines

#endif
}

+static void __adjust_discard_speed(unsigned int *interval,
+ unsigned int def_interval, int

dev_util)

Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines

+{
+ unsigned int base_interval, total_interval;
+
+ base_interval = def_interval / 10;
+ total_interval = def_interval - base_interval;
+
+ /*
+ * if def_interval = 100, adjusted interval should be in

range of

Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines

+ * [10, 100].
+ */
+ *interval = base_interval + total_interval * (100 -

dev_util) / 100;

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines

+}
+
+static void __tune_discard_policy(struct f2fs_sb_info *sbi,
+ struct discard_policy

*dpolicy)

Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines

+{
+ struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
+ int dev_util;
+
+ if (dcc->io_interrupted) {
+ dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
+ dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;

Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines

+ dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
+ return;
+ }
+
+ dev_util = dev_utilization(sbi);
+
+ __adjust_discard_speed(&dpolicy->min_interval,
+ DEF_MIN_DISCARD_ISSUE_TIME,

dev_util);

Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines

+ __adjust_discard_speed(&dpolicy->mid_interval,
+ DEF_MID_DISCARD_ISSUE_TIME,

dev_util);

Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines

+ __adjust_discard_speed(&dpolicy->max_interval,
+ DEF_MAX_DISCARD_ISSUE_TIME,

dev_util);

Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines

+}
+
static void __init_discard_policy(struct f2fs_sb_info *sbi,
struct discard_policy *dpolicy,
int discard_type, unsigned int

granularity)

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

@@ -982,20 +1020,11 @@ static void __init_discard_policy(struct

f2fs_sb_info *sbi,

Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines

dpolicy->io_aware_gran = MAX_PLIST_NUM;

if (discard_type == DPOLICY_BG) {
- dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
- dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
- dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
dpolicy->io_aware = true;
dpolicy->sync = false;
dpolicy->ordered = true;
- if (utilization(sbi) > DEF_DISCARD_URGENT_UTIL) {
- dpolicy->granularity = 1;
- dpolicy->max_interval =

DEF_MIN_DISCARD_ISSUE_TIME;

Quoted 10 lines
Quoted 10 lines
Quoted 10 lines
Quoted 10 lines
Quoted 10 lines
Quoted 10 lines
Quoted 10 lines
Quoted 10 lines
Quoted 10 lines
Quoted 10 lines

- }
+ __tune_discard_policy(sbi, dpolicy);
} else if (discard_type == DPOLICY_FORCE) {
- dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
- dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
- dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
dpolicy->io_aware = false;
} else if (discard_type == DPOLICY_FSTRIM) {
dpolicy->io_aware = false;
@@ -1353,6 +1382,8 @@ static unsigned int

__issue_discard_cmd_orderly(struct f2fs_sb_info *sbi,

Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines

if (!issued && io_interrupted)
issued = -1;

+ dcc->io_interrupted = io_interrupted;
+
return issued;
}

@@ -1370,7 +1401,7 @@ static int __issue_discard_cmd(struct

f2fs_sb_info *sbi,

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines

if (i + 1 < dpolicy->granularity)
break;

- if (i < DEFAULT_DISCARD_GRANULARITY &&

dpolicy->ordered)

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

+ if (i < MID_DISCARD_GRANULARITY &&

dpolicy->ordered)

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

return __issue_discard_cmd_orderly(sbi,

dpolicy);

Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines

pend_list = &dcc->pend_list[i];
@@ -1407,6 +1438,8 @@ static int __issue_discard_cmd(struct

f2fs_sb_info *sbi,

Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines

if (!issued && io_interrupted)
issued = -1;

+ dcc->io_interrupted = io_interrupted;
+
return issued;
}

@@ -1576,7 +1609,11 @@ static int issue_discard_thread(void

*data)

Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines

struct f2fs_sb_info *sbi = data;
struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
wait_queue_head_t *q = &dcc->discard_wait_queue;
- struct discard_policy dpolicy;
+ struct discard_policy dpolicy = {
+ .min_interval = DEF_MIN_DISCARD_ISSUE_TIME,
+ .mid_interval = DEF_MID_DISCARD_ISSUE_TIME,
+ .max_interval = DEF_MAX_DISCARD_ISSUE_TIME,
+ };
unsigned int wait_ms = DEF_MIN_DISCARD_ISSUE_TIME;
int issued;

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

@@ -1929,7 +1966,7 @@ static int

create_discard_cmd_control(struct f2fs_sb_info *sbi)

Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines

if (!dcc)
return -ENOMEM;

- dcc->discard_granularity = DEFAULT_DISCARD_GRANULARITY;
+ dcc->discard_granularity = MIN_DISCARD_GRANULARITY;
INIT_LIST_HEAD(&dcc->entry_list);
for (i = 0; i < MAX_PLIST_NUM; i++)
INIT_LIST_HEAD(&dcc->pend_list[i]);
@@ -1945,6 +1982,7 @@ static int

create_discard_cmd_control(struct f2fs_sb_info *sbi)

Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines

dcc->next_pos = 0;
dcc->root = RB_ROOT;
dcc->rbtree_check = false;
+ dcc->io_interrupted = false;

Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines

init_waitqueue_head(&dcc->discard_wait_queue);
SM_I(sbi)->dcc_info = dcc;
diff --git a/fs/f2fs/segment.h b/fs/f2fs/segment.h
index 422b0ceb1eaa..63b4da72cd34 100644
--- a/fs/f2fs/segment.h
+++ b/fs/f2fs/segment.h
@@ -616,6 +616,15 @@ static inline int utilization(struct

f2fs_sb_info *sbi)

Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines

sbi->user_block_count);
}

+static inline int dev_utilization(struct f2fs_sb_info *sbi)
+{
+ unsigned int dev_blks;
+
+ dev_blks = valid_user_blocks(sbi) +

SM_I(sbi)->dcc_info->undiscard_blks;

Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines

+ return div_u64((u64)dev_blks * 100,
+ MAIN_SEGS(sbi) << sbi->log_blocks_per_seg);
+}
+
/*
* Sometimes f2fs may be better to drop out-of-place update

policy.

Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines

* And, users can control the policy through sysfs entries.
diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index b055f2ea77c5..55ed76daad23 100644
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -2862,7 +2862,7 @@ static void f2fs_tuning_parameters(struct

f2fs_sb_info *sbi)

Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines

/* adjust parameters according to the volume size */
if (sm_i->main_segments <= SMALL_VOLUME_SEGMENTS) {
F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;
- sm_i->dcc_info->discard_granularity = 1;
+ sm_i->dcc_info->discard_granularity =

MIN_DISCARD_GRANULARITY;

Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 11 lines
Quoted 11 lines
Quoted 8 lines
Quoted 8 lines
Quoted 5 lines

sm_i->ipu_policy = 1 << F2FS_IPU_FORCE;
}

--
2.18.0.rc1

.

.

Quoted 8 lines
Quoted 5 lines
Quoted 5 lines
Quoted 2 lines
Quoted 2 lines

.

.

.

------------------------------------------------------------------------------
Check out the vibrant tech community on one of the world's most engaging tech sites, Slashdot.org! http://sdm.link/slashdot
_______________________________________________
Linux-f2fs-devel mailing list [email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel

.

maintainer
#15 lore raw

Re: [f2fs-dev] [PATCH 2/2] f2fs: tune discard speed with storage usage rate

Quoted 8 lines · Chao Yu
Quoted 7 lines · Jaegeuk Kim
Quoted 5 lines · Ju Hyung Park

btrfs also distinguishes high/low end SSDs with mount option "ssd" and "ssd_spread".
I believe there is no implementation inside btrfs to do it automatically.

Providing users an option with a well made documentation is acceptable imo.

Quoted 8 lines
Quoted 2 lines

Yeah, I was thinking about this as well. How about adding "-o disk=%s" where %s can be ufs/emmc/ssd/low_ssd/nvme/...?

Agreed,

Quoted 1 line

And, we also can decide the device type automatically w/ kmsg by default.

You mean by scanning kmsg to see the device type?

No, I was seeking for a way to find in block device structure, if exists.

Quoted 442 lines

Thanks,

Quoted 439 lines
Quoted 436 lines

And I personally think, if the default goes to a dynamically deciding method, it should tell it to kmsg.

Thanks,

Quoted 427 lines · Chao Yu
Quoted 10 lines · Jaegeuk Kim
Quoted 9 lines · Chao Yu
Quoted 8 lines · Jaegeuk Kim
Quoted 7 lines · Chao Yu
Quoted 6 lines · Jaegeuk Kim
Quoted 5 lines · Chao Yu
Quoted 4 lines · Jaegeuk Kim
Quoted 3 lines · Chao Yu
Quoted 2 lines · Jaegeuk Kim

On 08/10, Chao Yu wrote:
Previously, discard speed was fixed mostly, and in high usage

rate

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

device, we will speed up issuing discard, but it doesn't make

sense

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

that in a non-full filesystem, we still issue discard with slow

speed.

Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines

Could you please elaborate the problem in more detail? The speed

depends

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 1 line

on how many candidates?

undiscard blocks are all 4k granularity.
a) utility: filesystem: 20% + undiscard blocks: 20% = flash

storage: 40%

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

b) utility: filesystem: 40% + undiscard blocks: 25% = flash

storage: 65%

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

c) utility: filesystem: 60% + undiscard blocks: 30% = flash

storage: 100%

Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines

1. for case c), we need to speed up issuing discard based on

utilization of

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

"filesystem + undiscard" instead of just utilization of

filesystem.

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines

Review

Quoted 4 lines
(quoted diff) +0 -3
-              if (utilization(sbi) > DEF_DISCARD_URGENT_UTIL) {
-                      dpolicy->granularity = 1;
-                      dpolicy->max_interval =

DEF_MIN_DISCARD_ISSUE_TIME;

Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines

- }

2. If free space in storage touches therein threshold,

performance will be very

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

sensitive. In low-end storage, with high usage in space, even

free space is

Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 1 line

reduced by 1%, performance will decrease a lot.

So, we may need to distinguish low-end vs. high-end storage. In

high-end case,

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

it'd be better to avoid IO contention, while low-end device wants

to get more

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

discard commands as much as possible. So, how about adding an

option for this

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 1 line

as a tunable point?

Agreed, how about adding a sysfs entry discard_tunning:
1: enabled, use 4k granularity, self-adapted speed based on real

device free space.

Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 5 lines

0: disabled, use dcc->discard_granularity, fixed speed.

By default: enabled

How do you think?

I don't think this is proper with a sysfs entry, since we already

know the

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 2 lines

You mean by storage capacity? <= 32GB means low-end?

Yes, that's current condition to judge it. If there is any other

method, it'd be

Quoted 4 lines
Quoted 4 lines

That would be hard code...

Still I have not got any other method to do the judgment except

capacity.

Quoted 2 lines

Maybe ufs or emmc?

Yeah, that's may be a good way.

I remember very initial version UFS has very poor discard performance, for that
kind of storage, it will be not accurate?

Let me check whether there is a flag to distinguish ufs/emmc.

Thanks,

Quoted 10 lines
Quoted 10 lines

Thanks,

Quoted 6 lines

better to change it.

Quoted 4 lines

Thanks,

Quoted 1 line

device type when mounting the partition. We won't require to change

the policy

Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines

on the fly. And, I still don't get to change the default.

Quoted 6 lines

Thanks,

Quoted 3 lines
Quoted 3 lines

IMO, in above cases, we'd better to issue discard with high speed

for c), middle

Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines

speed for b), and low speed for a).

How do you think?

Thanks,

Quoted 5 lines

Thanks,

Anyway, it comes out undiscarded block makes FTL GC be lower

efficient

Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines

and causing high lifetime overhead.

Let's tune discard speed as below:

a. adjust default issue interval:
original after
min_interval: 50ms 100ms
mid_interval: 500ms 1000ms
max_interval: 60000ms 10000ms

b. if last time we stop issuing discard due to IO interruption

of user,

Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines

let's reset all {min,mid,max}_interval to default one.

c. tune {min,mid,max}_interval with below calculation method:

base_interval = default_interval / 10;
total_interval = default_interval - base_interval;
interval = base_interval + total_interval * (100 - dev_util) /

100;

Quoted 13 lines
Quoted 13 lines
Quoted 13 lines
Quoted 13 lines
Quoted 13 lines
Quoted 13 lines
Quoted 13 lines
Quoted 13 lines
Quoted 13 lines

For example:
min_interval (:100ms)
dev_util (%) interval (ms)
0 100
10 91
20 82
30 73
...
80 28
90 19
100 10

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines

Signed-off-by: Chao Yu <[email protected]>
---
fs/f2fs/f2fs.h | 11 ++++----
fs/f2fs/segment.c | 64

+++++++++++++++++++++++++++++++++++++----------

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines

fs/f2fs/segment.h | 9 +++++++
fs/f2fs/super.c | 2 +-
4 files changed, 67 insertions(+), 19 deletions(-)

Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 273ffdaf4891..a1dd2e1c3cb9 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -185,10 +185,9 @@ enum {

#define MAX_DISCARD_BLOCKS(sbi) BLKS_PER_SEC(sbi)
#define DEF_MAX_DISCARD_REQUEST 8 /* issue 8

discards per round */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

-#define DEF_MIN_DISCARD_ISSUE_TIME 50 /* 50 ms, if

exists */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

-#define DEF_MID_DISCARD_ISSUE_TIME 500 /* 500 ms, if

device busy */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

-#define DEF_MAX_DISCARD_ISSUE_TIME 60000 /* 60 s, if no

candidates */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

-#define DEF_DISCARD_URGENT_UTIL 80 /* do more

discard over 80% */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

+#define DEF_MIN_DISCARD_ISSUE_TIME 100 /* 100 ms, if

exists */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

+#define DEF_MID_DISCARD_ISSUE_TIME 1000 /* 1000 ms, if

device busy */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

+#define DEF_MAX_DISCARD_ISSUE_TIME 10000 /* 10000 ms, if no

candidates */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

#define DEF_CP_INTERVAL 60 /* 60 secs

*/

Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines

#define DEF_IDLE_INTERVAL 5 /* 5 secs */

@@ -248,7 +247,8 @@ struct discard_entry {
};

/* default discard granularity of inner discard thread, unit:

block count */

Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines

-#define DEFAULT_DISCARD_GRANULARITY 1
+#define MID_DISCARD_GRANULARITY 16
+#define MIN_DISCARD_GRANULARITY 1

/* max discard pend list number */
#define MAX_PLIST_NUM 512
@@ -330,6 +330,7 @@ struct discard_cmd_control {
atomic_t discard_cmd_cnt; /* # of cached cmd

count */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

struct rb_root root; /* root of discard

rb-tree */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

bool rbtree_check; /* config for

consistence check */

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

+ bool io_interrupted; /* last state of

io interrupted */

Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines

};

/* for the list of fsync inodes, used only during recovery */
diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 8b52e8dfb12f..9564aaf1f27b 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -968,6 +968,44 @@ static void __check_sit_bitmap(struct

f2fs_sb_info *sbi,

Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines

#endif
}

+static void __adjust_discard_speed(unsigned int *interval,
+ unsigned int def_interval, int

dev_util)

Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines

+{
+ unsigned int base_interval, total_interval;
+
+ base_interval = def_interval / 10;
+ total_interval = def_interval - base_interval;
+
+ /*
+ * if def_interval = 100, adjusted interval should be in

range of

Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines

+ * [10, 100].
+ */
+ *interval = base_interval + total_interval * (100 -

dev_util) / 100;

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines

+}
+
+static void __tune_discard_policy(struct f2fs_sb_info *sbi,
+ struct discard_policy

*dpolicy)

Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines

+{
+ struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
+ int dev_util;
+
+ if (dcc->io_interrupted) {
+ dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
+ dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;

Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines

+ dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
+ return;
+ }
+
+ dev_util = dev_utilization(sbi);
+
+ __adjust_discard_speed(&dpolicy->min_interval,
+ DEF_MIN_DISCARD_ISSUE_TIME,

dev_util);

Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines

+ __adjust_discard_speed(&dpolicy->mid_interval,
+ DEF_MID_DISCARD_ISSUE_TIME,

dev_util);

Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines

+ __adjust_discard_speed(&dpolicy->max_interval,
+ DEF_MAX_DISCARD_ISSUE_TIME,

dev_util);

Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines

+}
+
static void __init_discard_policy(struct f2fs_sb_info *sbi,
struct discard_policy *dpolicy,
int discard_type, unsigned int

granularity)

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

@@ -982,20 +1020,11 @@ static void __init_discard_policy(struct

f2fs_sb_info *sbi,

Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines

dpolicy->io_aware_gran = MAX_PLIST_NUM;

if (discard_type == DPOLICY_BG) {
- dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
- dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
- dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
dpolicy->io_aware = true;
dpolicy->sync = false;
dpolicy->ordered = true;
- if (utilization(sbi) > DEF_DISCARD_URGENT_UTIL) {
- dpolicy->granularity = 1;
- dpolicy->max_interval =

DEF_MIN_DISCARD_ISSUE_TIME;

Quoted 10 lines
Quoted 10 lines
Quoted 10 lines
Quoted 10 lines
Quoted 10 lines
Quoted 10 lines
Quoted 10 lines
Quoted 10 lines
Quoted 10 lines

- }
+ __tune_discard_policy(sbi, dpolicy);
} else if (discard_type == DPOLICY_FORCE) {
- dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
- dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
- dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
dpolicy->io_aware = false;
} else if (discard_type == DPOLICY_FSTRIM) {
dpolicy->io_aware = false;
@@ -1353,6 +1382,8 @@ static unsigned int

__issue_discard_cmd_orderly(struct f2fs_sb_info *sbi,

Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines

if (!issued && io_interrupted)
issued = -1;

+ dcc->io_interrupted = io_interrupted;
+
return issued;
}

@@ -1370,7 +1401,7 @@ static int __issue_discard_cmd(struct

f2fs_sb_info *sbi,

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines

if (i + 1 < dpolicy->granularity)
break;

- if (i < DEFAULT_DISCARD_GRANULARITY &&

dpolicy->ordered)

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

+ if (i < MID_DISCARD_GRANULARITY &&

dpolicy->ordered)

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

return __issue_discard_cmd_orderly(sbi,

dpolicy);

Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines

pend_list = &dcc->pend_list[i];
@@ -1407,6 +1438,8 @@ static int __issue_discard_cmd(struct

f2fs_sb_info *sbi,

Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines

if (!issued && io_interrupted)
issued = -1;

+ dcc->io_interrupted = io_interrupted;
+
return issued;
}

@@ -1576,7 +1609,11 @@ static int issue_discard_thread(void

*data)

Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines

struct f2fs_sb_info *sbi = data;
struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
wait_queue_head_t *q = &dcc->discard_wait_queue;
- struct discard_policy dpolicy;
+ struct discard_policy dpolicy = {
+ .min_interval = DEF_MIN_DISCARD_ISSUE_TIME,
+ .mid_interval = DEF_MID_DISCARD_ISSUE_TIME,
+ .max_interval = DEF_MAX_DISCARD_ISSUE_TIME,
+ };
unsigned int wait_ms = DEF_MIN_DISCARD_ISSUE_TIME;
int issued;

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

@@ -1929,7 +1966,7 @@ static int

create_discard_cmd_control(struct f2fs_sb_info *sbi)

Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines

if (!dcc)
return -ENOMEM;

- dcc->discard_granularity = DEFAULT_DISCARD_GRANULARITY;
+ dcc->discard_granularity = MIN_DISCARD_GRANULARITY;
INIT_LIST_HEAD(&dcc->entry_list);
for (i = 0; i < MAX_PLIST_NUM; i++)
INIT_LIST_HEAD(&dcc->pend_list[i]);
@@ -1945,6 +1982,7 @@ static int

create_discard_cmd_control(struct f2fs_sb_info *sbi)

Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines

dcc->next_pos = 0;
dcc->root = RB_ROOT;
dcc->rbtree_check = false;
+ dcc->io_interrupted = false;

Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines

init_waitqueue_head(&dcc->discard_wait_queue);
SM_I(sbi)->dcc_info = dcc;
diff --git a/fs/f2fs/segment.h b/fs/f2fs/segment.h
index 422b0ceb1eaa..63b4da72cd34 100644
--- a/fs/f2fs/segment.h
+++ b/fs/f2fs/segment.h
@@ -616,6 +616,15 @@ static inline int utilization(struct

f2fs_sb_info *sbi)

Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines

sbi->user_block_count);
}

+static inline int dev_utilization(struct f2fs_sb_info *sbi)
+{
+ unsigned int dev_blks;
+
+ dev_blks = valid_user_blocks(sbi) +

SM_I(sbi)->dcc_info->undiscard_blks;

Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines

+ return div_u64((u64)dev_blks * 100,
+ MAIN_SEGS(sbi) << sbi->log_blocks_per_seg);
+}
+
/*
* Sometimes f2fs may be better to drop out-of-place update

policy.

Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines

* And, users can control the policy through sysfs entries.
diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index b055f2ea77c5..55ed76daad23 100644
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -2862,7 +2862,7 @@ static void f2fs_tuning_parameters(struct

f2fs_sb_info *sbi)

Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines

/* adjust parameters according to the volume size */
if (sm_i->main_segments <= SMALL_VOLUME_SEGMENTS) {
F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;
- sm_i->dcc_info->discard_granularity = 1;
+ sm_i->dcc_info->discard_granularity =

MIN_DISCARD_GRANULARITY;

Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 11 lines
Quoted 11 lines
Quoted 8 lines
Quoted 8 lines

sm_i->ipu_policy = 1 << F2FS_IPU_FORCE;
}

--
2.18.0.rc1

.

.

Quoted 8 lines
Quoted 5 lines
Quoted 5 lines
Quoted 2 lines
Quoted 2 lines

.

.

.

------------------------------------------------------------------------------
Check out the vibrant tech community on one of the world's most engaging tech sites, Slashdot.org! http://sdm.link/slashdot
_______________________________________________
Linux-f2fs-devel mailing list [email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel

.

maintainer
#16 lore raw
In reply to Chao Yu
Quoted 6 lines · Chao Yu

Small granularity (size < 64K) fragmentation will cause f2fs suspending all pending discards, result in performance regression, so let's set 4KB discard granularity by default.

So that without fstrim, we also have the ability to avoid any performance regression caused by non-alignment mapping between fs and flash device.

This is why we added a sysfs entry. Why do we need to change the default value every time?

Quoted 21 lines
---
 fs/f2fs/f2fs.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
fs/f2fs/f2fs.h +1 -1
index 58431b9bfd8f..273ffdaf4891 100644
@@ -248,7 +248,7 @@ struct discard_entry {
 };
 
 /* default discard granularity of inner discard thread, unit: block count */
-#define DEFAULT_DISCARD_GRANULARITY		16
+#define DEFAULT_DISCARD_GRANULARITY		1
 
 /* max discard pend list number */
 #define MAX_PLIST_NUM		512
Signature · 1 line
2.18.0.rc1

------------------------------------------------------------------------------
Check out the vibrant tech community on one of the world's most engaging tech sites, Slashdot.org! http://sdm.link/slashdot

author
#17 lore raw
Quoted 10 lines · Jaegeuk Kim
Quoted 6 lines · Chao Yu

Small granularity (size < 64K) fragmentation will cause f2fs suspending all pending discards, result in performance regression, so let's set 4KB discard granularity by default.

So that without fstrim, we also have the ability to avoid any performance regression caused by non-alignment mapping between fs and flash device.

This is why we added a sysfs entry. Why do we need to change the default value every time?

Of course, I didn't forget it. But, mostly, our user didn't know very well about our filesystem including each configuration's meaning, mechanism, or usage scenario, most of the time, they will choose to test f2fs with all default option, and then make the conclusion.

Currently, with default 64k granularity, if we simulate fragmentation scenario of filesystem, like by a)writing 4k file and b)deleting even indexing file, then all 4k discards won't be issued, result in exhaustion of free space of flash storage, and performance degradation.

So I think we'd better to consider and set default value of configuration more elaborately to avoid obvious weakness.

Thoughts?

Thanks,

Quoted 25 lines
Quoted 22 lines
---
 fs/f2fs/f2fs.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
fs/f2fs/f2fs.h +1 -1
index 58431b9bfd8f..273ffdaf4891 100644
@@ -248,7 +248,7 @@ struct discard_entry {
 };
 
 /* default discard granularity of inner discard thread, unit: block count */
-#define DEFAULT_DISCARD_GRANULARITY		16
+#define DEFAULT_DISCARD_GRANULARITY		1
 
 /* max discard pend list number */
 #define MAX_PLIST_NUM		512
Signature · 1 line
2.18.0.rc1

.

#18 lore raw

Hi,

I was wondering what would be the negatives on reducing the discard granularity other than making discard more aggressive(hence higher overhead and latency?).

Thanks.

Quoted 64 lines · Chao Yu
Quoted 10 lines · Jaegeuk Kim
Quoted 6 lines · Chao Yu

Small granularity (size < 64K) fragmentation will cause f2fs suspending all pending discards, result in performance regression, so let's set 4KB discard granularity by default.

So that without fstrim, we also have the ability to avoid any performance regression caused by non-alignment mapping between fs and flash device.

This is why we added a sysfs entry. Why do we need to change the default value every time?

Of course, I didn't forget it. But, mostly, our user didn't know very well about our filesystem including each configuration's meaning, mechanism, or usage scenario, most of the time, they will choose to test f2fs with all default option, and then make the conclusion.

Currently, with default 64k granularity, if we simulate fragmentation scenario of filesystem, like by a)writing 4k file and b)deleting even indexing file, then all 4k discards won't be issued, result in exhaustion of free space of flash storage, and performance degradation.

So I think we'd better to consider and set default value of configuration more elaborately to avoid obvious weakness.

Thoughts?

Thanks,

Quoted 18 lines
Quoted 18 lines
---
 fs/f2fs/f2fs.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
fs/f2fs/f2fs.h +1 -1
index 58431b9bfd8f..273ffdaf4891 100644
@@ -248,7 +248,7 @@ struct discard_entry {
 };
 
 /* default discard granularity of inner discard thread, unit: block count */
-#define DEFAULT_DISCARD_GRANULARITY         16
+#define DEFAULT_DISCARD_GRANULARITY         1
 
Quoted 7 lines
Quoted 4 lines
fs/f2fs/f2fs.h +0 -1
 /* max discard pend list number */
 #define MAX_PLIST_NUM               512
--

2.18.0.rc1

.

------------------------------------------------------------------------------
Check out the vibrant tech community on one of the world's most engaging tech sites, Slashdot.org! http://sdm.link/slashdot
_______________________________________________
Linux-f2fs-devel mailing list [email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel

author
#19 lore raw

Hi,

Quoted 3 lines · Ju Hyung Park

Hi,

I was wondering what would be the negatives on reducing the discard granularity

We may send more small-sized discard, which cost more IO times and lifetime, but without this, we may heap up too many undiscard pages in device, it can make write GC slower and cost more flash lifetime.

Thanks,

Quoted 72 lines

other than making discard more aggressive(hence higher overhead and latency?).

Thanks.

Quoted 57 lines · Chao Yu
Quoted 10 lines · Jaegeuk Kim
Quoted 6 lines · Chao Yu

Small granularity (size < 64K) fragmentation will cause f2fs suspending all pending discards, result in performance regression, so let's set 4KB discard granularity by default.

So that without fstrim, we also have the ability to avoid any performance regression caused by non-alignment mapping between fs and flash device.

This is why we added a sysfs entry. Why do we need to change the default value every time?

Of course, I didn't forget it. But, mostly, our user didn't know very well about our filesystem including each configuration's meaning, mechanism, or usage scenario, most of the time, they will choose to test f2fs with all default option, and then make the conclusion.

Currently, with default 64k granularity, if we simulate fragmentation scenario of filesystem, like by a)writing 4k file and b)deleting even indexing file, then all 4k discards won't be issued, result in exhaustion of free space of flash storage, and performance degradation.

So I think we'd better to consider and set default value of configuration more elaborately to avoid obvious weakness.

Thoughts?

Thanks,

Quoted 18 lines
Quoted 18 lines
---
 fs/f2fs/f2fs.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
fs/f2fs/f2fs.h +1 -1
index 58431b9bfd8f..273ffdaf4891 100644
@@ -248,7 +248,7 @@ struct discard_entry {
 };
 
 /* default discard granularity of inner discard thread, unit: block count */
-#define DEFAULT_DISCARD_GRANULARITY         16
+#define DEFAULT_DISCARD_GRANULARITY         1
 
Quoted 7 lines
Quoted 4 lines
fs/f2fs/f2fs.h +0 -1
 /* max discard pend list number */
 #define MAX_PLIST_NUM               512
--

2.18.0.rc1

.

Quoted 7 lines

------------------------------------------------------------------------------
Check out the vibrant tech community on one of the world's most engaging tech sites, Slashdot.org! http://sdm.link/slashdot
_______________________________________________
Linux-f2fs-devel mailing list [email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel

.