f2fs: set 4KB discard granularity by default
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
@@ -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
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 aftermin_interval: 50ms 100msmid_interval: 500ms 1000msmax_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
@@ -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
@@ -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
@@ -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
Jaegeuk Kim
maintainerRe: [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 aftermin_interval: 50ms 100msmid_interval: 500ms 1000msmax_interval: 60000ms 10000msb. 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 10Signed-off-by Chao Yu <[email protected]>--- 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@@ -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@@ -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@@ -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@@ -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
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 aftermin_interval: 50ms 100msmid_interval: 500ms 1000msmax_interval: 60000ms 10000msb. 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 10Signed-off-by Chao Yu <[email protected]>--- 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@@ -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@@ -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@@ -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@@ -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.
Jaegeuk Kim
maintainerRe: [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 aftermin_interval: 50ms 100msmid_interval: 500ms 1000msmax_interval: 60000ms 10000msb. 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 10Signed-off-by Chao Yu <[email protected]>--- 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@@ -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@@ -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@@ -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@@ -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.
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 aftermin_interval: 50ms 100msmid_interval: 500ms 1000msmax_interval: 60000ms 10000msb. 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 10Signed-off-by Chao Yu <[email protected]>--- 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@@ -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@@ -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@@ -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@@ -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.
.
Jaegeuk Kim
maintainerRe: [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, usedcc->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 aftermin_interval: 50ms 100msmid_interval: 500ms 1000msmax_interval: 60000ms 10000msb. 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 10Signed-off-by Chao Yu <[email protected]>--- 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@@ -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@@ -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@@ -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@@ -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.
.
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, usedcc->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 aftermin_interval: 50ms 100msmid_interval: 500ms 1000msmax_interval: 60000ms 10000msb. 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 10Signed-off-by Chao Yu <[email protected]>--- 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@@ -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@@ -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@@ -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@@ -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.
.
.
Jaegeuk Kim
maintainerRe: [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, usedcc->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 aftermin_interval: 50ms 100msmid_interval: 500ms 1000msmax_interval: 60000ms 10000msb. 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 10Signed-off-by Chao Yu <[email protected]>--- 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@@ -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@@ -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@@ -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@@ -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.
.
.
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, usedcc->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 aftermin_interval: 50ms 100msmid_interval: 500ms 1000msmax_interval: 60000ms 10000msb. 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 10Signed-off-by Chao Yu <[email protected]>--- 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@@ -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@@ -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@@ -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@@ -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.
.
.
.
Jaegeuk Kim
maintainerRe: [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, usedcc->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 aftermin_interval: 50ms 100msmid_interval: 500ms 1000msmax_interval: 60000ms 10000msb. 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 10Signed-off-by Chao Yu <[email protected]>--- 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@@ -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@@ -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@@ -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@@ -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
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, usedcc->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 aftermin_interval: 50ms 100msmid_interval: 500ms 1000msmax_interval: 60000ms 10000msb. 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 10Signed-off-by Chao Yu <[email protected]>--- 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@@ -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@@ -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@@ -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@@ -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
Jaegeuk Kim
maintainerRe: [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% = flashstorage: 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 realdevice 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 aftermin_interval: 50ms 100ms mid_interval: 500ms 1000ms max_interval: 60000ms 10000msb. 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 10Quoted 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
fs/f2fs/f2fs.h enum { · line 187
Quoted 8 lines
fs/f2fs/f2fs.h +0
-0@@ -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
-0struct 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
-0bool 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@@ -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 intgranularity)
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
-6dpolicy->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
-0if (!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
-1if (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
-0return __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
-0pend_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
-0if (!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
-1struct 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
-1if (!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
-0dcc->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
-0init_waitqueue_head (&dcc->discard_wait_queue);SM_I (sbi)->dcc_info = dcc;fs/f2fs/segment.h +0
-0@@ -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
-0sbi->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@@ -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
-1sm_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
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% = flashstorage: 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 realdevice 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 10000msb. 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 10Quoted 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 8discards 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 cmdcount */
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 inrange 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 intgranularity)
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 updatepolicy.
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.
Jaegeuk Kim
maintainerRe: [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 usagerate
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% = flashstorage: 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 realdevice 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 10000msb. 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 10Quoted 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 8discards 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 cmdcount */
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 inrange 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 intgranularity)
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 updatepolicy.
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.
Jaegeuk Kim
maintainerQuoted 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
Signed-off-by Chao Yu <[email protected]>--- fs/f2fs/f2fs.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)fs/f2fs/f2fs.h +1
-1@@ -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 512Signature · 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
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
Signed-off-by Chao Yu <[email protected]>--- fs/f2fs/f2fs.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)fs/f2fs/f2fs.h +1
-1@@ -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 512Signature · 1 line
2.18.0.rc1.
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
Signed-off-by Chao Yu <[email protected]>--- fs/f2fs/f2fs.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)fs/f2fs/f2fs.h +1
-1@@ -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 1Quoted 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
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
Signed-off-by Chao Yu <[email protected]>--- fs/f2fs/f2fs.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)fs/f2fs/f2fs.h +1
-1@@ -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 1Quoted 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.