f2fs: fix performance issue observed with multi-thread sequential read
Jaegeuk Kim
maintainerPATCH 1/1 f2fs: fix performance issue observed with multi-thread sequential read
This reverts the commit - "b93f771 - f2fs: remove writepages lock" to fix the drop in sequential read throughput.
Test: ./tiotest -t 32 -d /data/tio_tmp -f 32 -b 524288 -k 1 -k 3 -L
device: UFS
Before -
read throughput: 185 MB/s
total read requests: 85177 (of these ~80000 are 4KB size requests). total write requests: 2546 (of these ~2208 requests are written in 512KB).
After -
read throughput: 758 MB/s
total read requests: 2417 (of these ~2042 are 512KB reads). total write requests: 2701 (of these ~2034 requests are written in 512KB).
--- fs/f2fs/data.c | 14 ++++++++++++-- fs/f2fs/f2fs.h | 1 + fs/f2fs/super.c | 1 + 3 files changed, 14 insertions(+), 2 deletions(-)
fs/f2fs/data.c +12 -2
@@ -2132,6 +2132,7 @@ static int __f2fs_write_data_pages(struct address_space *mapping,struct f2fs_sb_info *sbi =F2FS_I_SB (inode);struct blk_plug plug;int ret; +bool locked = false;/* deal with chardevs and other special file */ if (!mapping->a_ops->writepage)
@@ -2157,15 +2158,24 @@ static int __f2fs_write_data_pages(struct address_space *mapping,trace_f2fs_writepages (mapping->host, wbc,DATA );/* to avoid spliting IOs due to mixed WB_SYNC_ALL and WB_SYNC_NONE */ -if (wbc->sync_mode ==WB_SYNC_ALL ) +if (wbc->sync_mode ==WB_SYNC_ALL ) {atomic_inc (&sbi->wb_sync_req[DATA ]); -else if (atomic_read (&sbi->wb_sync_req[DATA ])) +mutex_lock (&sbi->writepages); + locked = true; + }else if (atomic_read (&sbi->wb_sync_req[DATA ])) { goto skip_write; + }else { +atomic_inc (&sbi->wb_sync_req[DATA ]); +mutex_lock (&sbi->writepages); + }blk_start_plug (&plug); ret =f2fs_write_cache_pages (mapping, wbc, io_type);blk_finish_plug (&plug); +if (locked) +mutex_unlock (&sbi->writepages); +if (wbc->sync_mode ==WB_SYNC_ALL )atomic_dec (&sbi->wb_sync_req[DATA ]);/*
fs/f2fs/f2fs.h +1 -0
@@ -1133,6 +1133,7 @@ struct f2fs_sb_info {struct rw_semaphore sb_lock;/* lock for raw super block */ int valid_super_block;/* valid super block no */ unsigned long s_flag;/* flags for sbi */ +struct mutex writepages;/* mutex for writepages() */ #ifdef CONFIG_BLK_DEV_ZONED unsigned int blocks_per_blkz;/* F2FS blocks per zone */
fs/f2fs/super.c +1 -0
@@ -2842,6 +2842,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)/* init f2fs-specific super block info */ sbi->valid_super_block = valid_super_block;mutex_init (&sbi->gc_mutex); +mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);
Signature · 1 line
2.17.0.441.gb46fe60e1d-goog
Jaegeuk Kim
maintainerThis reverts the commit - "b93f771 - f2fs: remove writepages lock" to fix the drop in sequential read throughput.
Test: ./tiotest -t 32 -d /data/tio_tmp -f 32 -b 524288 -k 1 -k 3 -L
device: UFS
Before -
read throughput: 185 MB/s
total read requests: 85177 (of these ~80000 are 4KB size requests). total write requests: 2546 (of these ~2208 requests are written in 512KB).
After -
read throughput: 758 MB/s
total read requests: 2417 (of these ~2042 are 512KB reads). total write requests: 2701 (of these ~2034 requests are written in 512KB).
---
Change log from v1:
- quick code fix
fs/f2fs/data.c | 14 ++++++++++++-- fs/f2fs/f2fs.h | 1 + fs/f2fs/super.c | 1 + 3 files changed, 14 insertions(+), 2 deletions(-)
fs/f2fs/data.c +12 -2
@@ -2132,6 +2132,7 @@ static int __f2fs_write_data_pages(struct address_space *mapping,struct f2fs_sb_info *sbi =F2FS_I_SB (inode);struct blk_plug plug;int ret; +bool locked = false;/* deal with chardevs and other special file */ if (!mapping->a_ops->writepage)
@@ -2157,15 +2158,24 @@ static int __f2fs_write_data_pages(struct address_space *mapping,trace_f2fs_writepages (mapping->host, wbc,DATA );/* to avoid spliting IOs due to mixed WB_SYNC_ALL and WB_SYNC_NONE */ -if (wbc->sync_mode ==WB_SYNC_ALL ) +if (wbc->sync_mode ==WB_SYNC_ALL ) {atomic_inc (&sbi->wb_sync_req[DATA ]); -else if (atomic_read (&sbi->wb_sync_req[DATA ])) + goto writepages_lock; + }else if (atomic_read (&sbi->wb_sync_req[DATA ])) { goto skip_write; + }else { +writepages_lock: +mutex_lock (&sbi->writepages); + locked = true; + }blk_start_plug (&plug); ret =f2fs_write_cache_pages (mapping, wbc, io_type);blk_finish_plug (&plug); +if (locked) +mutex_unlock (&sbi->writepages); +if (wbc->sync_mode ==WB_SYNC_ALL )atomic_dec (&sbi->wb_sync_req[DATA ]);/*
fs/f2fs/f2fs.h +1 -0
@@ -1133,6 +1133,7 @@ struct f2fs_sb_info {struct rw_semaphore sb_lock;/* lock for raw super block */ int valid_super_block;/* valid super block no */ unsigned long s_flag;/* flags for sbi */ +struct mutex writepages;/* mutex for writepages() */ #ifdef CONFIG_BLK_DEV_ZONED unsigned int blocks_per_blkz;/* F2FS blocks per zone */
fs/f2fs/super.c +1 -0
@@ -2842,6 +2842,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)/* init f2fs-specific super block info */ sbi->valid_super_block = valid_super_block;mutex_init (&sbi->gc_mutex); +mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);
Signature · 1 line
2.17.0.441.gb46fe60e1d-goog
Jaegeuk Kim
maintainerThis reverts the commit - "b93f771 - f2fs: remove writepages lock" to fix the drop in sequential read throughput.
Test: ./tiotest -t 32 -d /data/tio_tmp -f 32 -b 524288 -k 1 -k 3 -L
device: UFS
Before -
read throughput: 185 MB/s
total read requests: 85177 (of these ~80000 are 4KB size requests). total write requests: 2546 (of these ~2208 requests are written in 512KB).
After -
read throughput: 758 MB/s
total read requests: 2417 (of these ~2042 are 512KB reads). total write requests: 2701 (of these ~2034 requests are written in 512KB).
---
Changelog from v2:
- fix deadlock in f2fs_gc
fs/f2fs/data.c | 9 +++++++++ fs/f2fs/f2fs.h | 1 + fs/f2fs/super.c | 1 + 3 files changed, 11 insertions(+)
fs/f2fs/data.c +9 -0
@@ -2132,6 +2132,7 @@ static int __f2fs_write_data_pages(struct address_space *mapping,struct f2fs_sb_info *sbi =F2FS_I_SB (inode);struct blk_plug plug;int ret; +bool locked = false;/* deal with chardevs and other special file */ if (!mapping->a_ops->writepage)
@@ -2162,10 +2163,18 @@ static int __f2fs_write_data_pages(struct address_space *mapping,else if (atomic_read (&sbi->wb_sync_req[DATA ])) goto skip_write; +if (!S_ISDIR (inode->i_mode)) { +mutex_lock (&sbi->writepages); + locked = true; + } +blk_start_plug (&plug); ret =f2fs_write_cache_pages (mapping, wbc, io_type);blk_finish_plug (&plug); +if (locked) +mutex_unlock (&sbi->writepages); +if (wbc->sync_mode ==WB_SYNC_ALL )atomic_dec (&sbi->wb_sync_req[DATA ]);/*
fs/f2fs/f2fs.h +1 -0
@@ -1133,6 +1133,7 @@ struct f2fs_sb_info {struct rw_semaphore sb_lock;/* lock for raw super block */ int valid_super_block;/* valid super block no */ unsigned long s_flag;/* flags for sbi */ +struct mutex writepages;/* mutex for writepages() */ #ifdef CONFIG_BLK_DEV_ZONED unsigned int blocks_per_blkz;/* F2FS blocks per zone */
fs/f2fs/super.c +1 -0
@@ -2842,6 +2842,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)/* init f2fs-specific super block info */ sbi->valid_super_block = valid_super_block;mutex_init (&sbi->gc_mutex); +mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);
Signature · 1 line
2.17.0.441.gb46fe60e1d-goog
Hi Jaegeuk,
Quoted 11 lines · Jaegeuk Kim
This reverts the commit - "b93f771 - f2fs: remove writepages lock" to fix the drop in sequential read throughput.
Test: ./tiotest -t 32 -d /data/tio_tmp -f 32 -b 524288 -k 1 -k 3 -L
device: UFSBefore -
read throughput: 185 MB/s
total read requests: 85177 (of these ~80000 are 4KB size requests). total write requests: 2546 (of these ~2208 requests are written in 512KB).
Quoted 4 lines
After -
read throughput: 758 MB/s
total read requests: 2417 (of these ~2042 are 512KB reads). total write requests: 2701 (of these ~2034 requests are written in 512KB).
IMO, it only impact sequential read performance in a large file which may be fragmented during multi-thread writing.
In android environment, mostly, the large file should be cold type, such as apk, mp3, rmvb, jpeg..., so I think we only need to serialize writepages() for cold data area writer.
So how about adding a mount option to serialize writepage() for different type of log, e.g. in android, using serialize=4; by default, using serialize=7HOT_DATA 1WARM_DATA 2COLD_DATA 4
Thanks,
Quoted 61 lines
Signed-off-by Sahitya Tummala <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>---
Changelog from v2:
- fix deadlock inf2fs_gcfs/f2fs/data.c | 9 +++++++++ fs/f2fs/f2fs.h | 1 + fs/f2fs/super.c | 1 + 3 files changed, 11 insertions(+)fs/f2fs/data.c +9
-0@@ -2132,6 +2132,7 @@ static int __f2fs_write_data_pages(struct address_space *mapping,struct f2fs_sb_info *sbi =F2FS_I_SB (inode);struct blk_plug plug;int ret; +bool locked = false;/* deal with chardevs and other special file */ if (!mapping->a_ops->writepage)@@ -2162,10 +2163,18 @@ static int __f2fs_write_data_pages(struct address_space *mapping,else if (atomic_read (&sbi->wb_sync_req[DATA ])) goto skip_write; +if (!S_ISDIR (inode->i_mode)) { +mutex_lock (&sbi->writepages); + locked = true; + } +blk_start_plug (&plug); ret =f2fs_write_cache_pages (mapping, wbc, io_type);blk_finish_plug (&plug); +if (locked) +mutex_unlock (&sbi->writepages); +if (wbc->sync_mode ==WB_SYNC_ALL )atomic_dec (&sbi->wb_sync_req[DATA ]);/* fs/f2fs/f2fs.h +1
-0@@ -1133,6 +1133,7 @@ struct f2fs_sb_info {struct rw_semaphore sb_lock;/* lock for raw super block */ int valid_super_block;/* valid super block no */ unsigned long s_flag;/* flags for sbi */ +struct mutex writepages;/* mutex for writepages() */ #ifdef CONFIG_BLK_DEV_ZONED unsigned int blocks_per_blkz;/* F2FS blocks per zone */ fs/f2fs/super.c +0
-0
fs/f2fs/super.c static int f2fs_fill_super(struct super_block *sb, void *data, int silent) · line 2848
Quoted 7 lines
fs/f2fs/super.c +1
-0@@ -2842,6 +2842,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)/* init f2fs-specific super block info */ sbi->valid_super_block = valid_super_block;mutex_init (&sbi->gc_mutex); +mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);
------------------------------------------------------------------------------
Check out the vibrant tech community on one of the world's most engaging tech sites, Slashdot.org! http://sdm.link/slashdot
Jaegeuk Kim
maintainerQuoted 26 lines · Chao Yu
Hi Jaegeuk,
Quoted 11 lines · Jaegeuk Kim
This reverts the commit - "b93f771 - f2fs: remove writepages lock" to fix the drop in sequential read throughput.
Test: ./tiotest -t 32 -d /data/tio_tmp -f 32 -b 524288 -k 1 -k 3 -L
device: UFSBefore -
read throughput: 185 MB/s
total read requests: 85177 (of these ~80000 are 4KB size requests). total write requests: 2546 (of these ~2208 requests are written in 512KB).Quoted 4 lines
After -
read throughput: 758 MB/s
total read requests: 2417 (of these ~2042 are 512KB reads). total write requests: 2701 (of these ~2034 requests are written in 512KB).IMO, it only impact sequential read performance in a large file which may be fragmented during multi-thread writing.
In android environment, mostly, the large file should be cold type, such as apk, mp3, rmvb, jpeg..., so I think we only need to serialize
writepages()for cold data area writer.
Quoted 5 lines
So how about adding a mount option to serialize
writepage()for different type of log, e.g. in android, using serialize=4; by default, using serialize=7HOT_DATA1WARM_DATA2COLD_DATA4
Well, I don't think we need to give too many mount options for this fragmented case. How about doing this for the large files only like this?
Quoted 1 line
From
4fea0b6e4da8512a72dd52afc7a51beb35966ad9Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <[email protected]>
Date: Thu, 9 Aug 2018 17:53:34 -0700
Subject: [PATCH] f2fs: fix performance issue observed with multi-thread
sequential read
This reverts the commit - "b93f771 - f2fs: remove writepages lock" to fix the drop in sequential read throughput.
Test: ./tiotest -t 32 -d /data/tio_tmp -f 32 -b 524288 -k 1 -k 3 -L
device: UFS
Before -
read throughput: 185 MB/s
total read requests: 85177 (of these ~80000 are 4KB size requests). total write requests: 2546 (of these ~2208 requests are written in 512KB).
After -
read throughput: 758 MB/s
total read requests: 2417 (of these ~2042 are 512KB reads). total write requests: 2701 (of these ~2034 requests are written in 512KB).
--- Documentation/ABI/testing/sysfs-fs-f2fs | 8 ++++++++ fs/f2fs/data.c | 10 ++++++++++ fs/f2fs/f2fs.h | 2 ++ fs/f2fs/segment.c | 1 + fs/f2fs/super.c | 1 + fs/f2fs/sysfs.c | 2 ++ 6 files changed, 24 insertions(+)
Documentation/ABI/testing/sysfs-fs-f2fs +8 -0
@@ -51,6 +51,14 @@ Description: Controls the dirty page count condition for the in-place-update policies. +What: /sys/fs/f2fs/<disk>/min_seq_blocks +Date: August 2018 +Contact: "Jaegeuk Kim" <[email protected]> +Description: + Controls the dirty page count condition for batched sequential + writes in ->writepages. + + What: /sys/fs/f2fs/<disk>/min_hot_blocks Date: March 2017 Contact: "Jaegeuk Kim" <[email protected]>
fs/f2fs/data.c +10 -0
@@ -2132,6 +2132,7 @@ static int __f2fs_write_data_pages(struct address_space *mapping,struct f2fs_sb_info *sbi =F2FS_I_SB (inode);struct blk_plug plug;int ret; +bool locked = false;/* deal with chardevs and other special file */ if (!mapping->a_ops->writepage)
@@ -2162,10 +2163,19 @@ static int __f2fs_write_data_pages(struct address_space *mapping,else if (atomic_read (&sbi->wb_sync_req[DATA ])) goto skip_write; +if (!S_ISDIR (inode->i_mode) && +get_dirty_pages (inode) <=SM_I (sbi)->min_seq_blocks) { +mutex_lock (&sbi->writepages); + locked = true; + } +blk_start_plug (&plug); ret =f2fs_write_cache_pages (mapping, wbc, io_type);blk_finish_plug (&plug); +if (locked) +mutex_unlock (&sbi->writepages); +if (wbc->sync_mode ==WB_SYNC_ALL )atomic_dec (&sbi->wb_sync_req[DATA ]);/*
fs/f2fs/f2fs.h +2 -0
@@ -913,6 +913,7 @@ struct f2fs_sm_info {unsigned int ipu_policy;/* in-place-update policy */ unsigned int min_ipu_util;/* in-place-update threshold */ unsigned int min_fsync_blocks;/* threshold for fsync */ +unsigned int min_seq_blocks;/* threshold for sequential blocks */ unsigned int min_hot_blocks;/* threshold for hot block allocation */ unsigned int min_ssr_sections;/* threshold to trigger SSR allocation */
@@ -1133,6 +1134,7 @@ struct f2fs_sb_info {struct rw_semaphore sb_lock;/* lock for raw super block */ int valid_super_block;/* valid super block no */ unsigned long s_flag;/* flags for sbi */ +struct mutex writepages;/* mutex for writepages() */ #ifdef CONFIG_BLK_DEV_ZONED unsigned int blocks_per_blkz;/* F2FS blocks per zone */
fs/f2fs/segment.c +1 -0
@@ -4131,6 +4131,7 @@ int f2fs_build_segment_manager(struct f2fs_sb_info *sbi) sm_info->ipu_policy =1 <<F2FS_IPU_FSYNC ; sm_info->min_ipu_util =DEF_MIN_IPU_UTIL ; sm_info->min_fsync_blocks =DEF_MIN_FSYNC_BLOCKS ; + sm_info->min_seq_blocks = sbi->blocks_per_seg * sbi->segs_per_sec; sm_info->min_hot_blocks =DEF_MIN_HOT_BLOCKS ; sm_info->min_ssr_sections =reserved_sections (sbi);
fs/f2fs/super.c +1 -0
@@ -2842,6 +2842,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)/* init f2fs-specific super block info */ sbi->valid_super_block = valid_super_block;mutex_init (&sbi->gc_mutex); +mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);
fs/f2fs/sysfs.c +2 -0
@@ -397,6 +397,7 @@ F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, batched_trim_sections, trim_sections);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, ipu_policy, ipu_policy);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_ipu_util, min_ipu_util);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_fsync_blocks, min_fsync_blocks); +F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_seq_blocks, min_seq_blocks);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_hot_blocks, min_hot_blocks);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_ssr_sections, min_ssr_sections);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ram_thresh, ram_thresh);
@@ -449,6 +450,7 @@ static struct attribute *f2fs_attrs[] = {ATTR_LIST (ipu_policy),ATTR_LIST (min_ipu_util),ATTR_LIST (min_fsync_blocks), +ATTR_LIST (min_seq_blocks),ATTR_LIST (min_hot_blocks),ATTR_LIST (min_ssr_sections), ATTR_LIST(max_victim_search),
Signature · 1 line
2.17.0.441.gb46fe60e1d-goog
Quoted 27 lines · Jaegeuk Kim
Quoted 26 lines · Chao Yu
Hi Jaegeuk,
Quoted 11 lines · Jaegeuk Kim
This reverts the commit - "b93f771 - f2fs: remove writepages lock" to fix the drop in sequential read throughput.
Test: ./tiotest -t 32 -d /data/tio_tmp -f 32 -b 524288 -k 1 -k 3 -L
device: UFSBefore -
read throughput: 185 MB/s
total read requests: 85177 (of these ~80000 are 4KB size requests). total write requests: 2546 (of these ~2208 requests are written in 512KB).Quoted 4 lines
After -
read throughput: 758 MB/s
total read requests: 2417 (of these ~2042 are 512KB reads). total write requests: 2701 (of these ~2034 requests are written in 512KB).IMO, it only impact sequential read performance in a large file which may be fragmented during multi-thread writing.
In android environment, mostly, the large file should be cold type, such as apk, mp3, rmvb, jpeg..., so I think we only need to serialize
writepages()for cold data area writer.
Quoted 8 lines
Quoted 5 lines
So how about adding a mount option to serialize
writepage()for different type of log, e.g. in android, using serialize=4; by default, using serialize=7HOT_DATA1WARM_DATA2COLD_DATA4Well, I don't think we need to give too many mount options for this fragmented case. How about doing this for the large files only like this?
Thread A write 512 pages Thread B write 8 pages
- writepages()
- mutex_lock(&sbi->writepages);
- writepage();
...
- writepages()
- writepage()
....
- writepage();
...
- mutex_unlock(&sbi->writepages);
Above case will also cause fragmentation since we didn't serialize all concurrent IO with the lock.
Do we need to consider such case?
Thanks,
Quoted 150 lines
Quoted 2 lines
From
4fea0b6e4da8512a72dd52afc7a51beb35966ad9Mon Sep 17 00:00:00 2001From: Jaegeuk Kim <[email protected]>
Date: Thu, 9 Aug 2018 17:53:34 -0700
Subject: [PATCH] f2fs: fix performance issue observed with multi-thread
sequential readThis reverts the commit - "b93f771 - f2fs: remove writepages lock" to fix the drop in sequential read throughput.
Test: ./tiotest -t 32 -d /data/tio_tmp -f 32 -b 524288 -k 1 -k 3 -L
device: UFSBefore -
read throughput: 185 MB/s
total read requests: 85177 (of these ~80000 are 4KB size requests). total write requests: 2546 (of these ~2208 requests are written in 512KB).After -
read throughput: 758 MB/s
total read requests: 2417 (of these ~2042 are 512KB reads). total write requests: 2701 (of these ~2034 requests are written in 512KB).Signed-off-by Sahitya Tummala <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>--- Documentation/ABI/testing/sysfs-fs-f2fs | 8 ++++++++ fs/f2fs/data.c | 10 ++++++++++ fs/f2fs/f2fs.h | 2 ++ fs/f2fs/segment.c | 1 + fs/f2fs/super.c | 1 + fs/f2fs/sysfs.c | 2 ++ 6 files changed, 24 insertions(+)Documentation/ABI/testing/sysfs-fs-f2fs +8
-0@@ -51,6 +51,14 @@ Description: Controls the dirty page count condition for the in-place-update policies. +What: /sys/fs/f2fs/<disk>/min_seq_blocks +Date: August 2018 +Contact: "Jaegeuk Kim" <[email protected]> +Description: + Controls the dirty page count condition for batched sequential + writes in ->writepages. + + What: /sys/fs/f2fs/<disk>/min_hot_blocks Date: March 2017 Contact: "Jaegeuk Kim" <[email protected]>fs/f2fs/data.c +10
-0@@ -2132,6 +2132,7 @@ static int __f2fs_write_data_pages(struct address_space *mapping,struct f2fs_sb_info *sbi =F2FS_I_SB (inode);struct blk_plug plug;int ret; +bool locked = false;/* deal with chardevs and other special file */ if (!mapping->a_ops->writepage)@@ -2162,10 +2163,19 @@ static int __f2fs_write_data_pages(struct address_space *mapping,else if (atomic_read (&sbi->wb_sync_req[DATA ])) goto skip_write; +if (!S_ISDIR (inode->i_mode) && +get_dirty_pages (inode) <=SM_I (sbi)->min_seq_blocks) { +mutex_lock (&sbi->writepages); + locked = true; + } +blk_start_plug (&plug); ret =f2fs_write_cache_pages (mapping, wbc, io_type);blk_finish_plug (&plug); +if (locked) +mutex_unlock (&sbi->writepages); +if (wbc->sync_mode ==WB_SYNC_ALL )atomic_dec (&sbi->wb_sync_req[DATA ]);/* fs/f2fs/f2fs.h +2
-0@@ -913,6 +913,7 @@ struct f2fs_sm_info {unsigned int ipu_policy;/* in-place-update policy */ unsigned int min_ipu_util;/* in-place-update threshold */ unsigned int min_fsync_blocks;/* threshold for fsync */ +unsigned int min_seq_blocks;/* threshold for sequential blocks */ unsigned int min_hot_blocks;/* threshold for hot block allocation */ unsigned int min_ssr_sections;/* threshold to trigger SSR allocation */ @@ -1133,6 +1134,7 @@ struct f2fs_sb_info {struct rw_semaphore sb_lock;/* lock for raw super block */ int valid_super_block;/* valid super block no */ unsigned long s_flag;/* flags for sbi */ +struct mutex writepages;/* mutex for writepages() */ #ifdef CONFIG_BLK_DEV_ZONED unsigned int blocks_per_blkz;/* F2FS blocks per zone */ fs/f2fs/segment.c +1
-0@@ -4131,6 +4131,7 @@ int f2fs_build_segment_manager(struct f2fs_sb_info *sbi) sm_info->ipu_policy =1 <<F2FS_IPU_FSYNC ; sm_info->min_ipu_util =DEF_MIN_IPU_UTIL ; sm_info->min_fsync_blocks =DEF_MIN_FSYNC_BLOCKS ; + sm_info->min_seq_blocks = sbi->blocks_per_seg * sbi->segs_per_sec; sm_info->min_hot_blocks =DEF_MIN_HOT_BLOCKS ; sm_info->min_ssr_sections =reserved_sections (sbi);fs/f2fs/super.c +1
-0@@ -2842,6 +2842,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)/* init f2fs-specific super block info */ sbi->valid_super_block = valid_super_block;mutex_init (&sbi->gc_mutex); +mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);fs/f2fs/sysfs.c +2
-0@@ -397,6 +397,7 @@ F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, batched_trim_sections, trim_sections);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, ipu_policy, ipu_policy);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_ipu_util, min_ipu_util);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_fsync_blocks, min_fsync_blocks); +F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_seq_blocks, min_seq_blocks);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_hot_blocks, min_hot_blocks);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_ssr_sections, min_ssr_sections);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ram_thresh, ram_thresh);@@ -449,6 +450,7 @@ static struct attribute *f2fs_attrs[] = {ATTR_LIST (ipu_policy),ATTR_LIST (min_ipu_util),ATTR_LIST (min_fsync_blocks), +ATTR_LIST (min_seq_blocks),ATTR_LIST (min_hot_blocks),ATTR_LIST (min_ssr_sections), ATTR_LIST(max_victim_search),
Jaegeuk Kim
maintainerQuoted 50 lines · Chao Yu
Quoted 27 lines · Jaegeuk Kim
Quoted 26 lines · Chao Yu
Hi Jaegeuk,
Quoted 11 lines · Jaegeuk Kim
This reverts the commit - "b93f771 - f2fs: remove writepages lock" to fix the drop in sequential read throughput.
Test: ./tiotest -t 32 -d /data/tio_tmp -f 32 -b 524288 -k 1 -k 3 -L
device: UFSBefore -
read throughput: 185 MB/s
total read requests: 85177 (of these ~80000 are 4KB size requests). total write requests: 2546 (of these ~2208 requests are written in 512KB).Quoted 4 lines
After -
read throughput: 758 MB/s
total read requests: 2417 (of these ~2042 are 512KB reads). total write requests: 2701 (of these ~2034 requests are written in 512KB).IMO, it only impact sequential read performance in a large file which may be fragmented during multi-thread writing.
In android environment, mostly, the large file should be cold type, such as apk, mp3, rmvb, jpeg..., so I think we only need to serialize
writepages()for cold data area writer.Quoted 8 lines
Quoted 5 lines
So how about adding a mount option to serialize
writepage()for different type of log, e.g. in android, using serialize=4; by default, using serialize=7HOT_DATA1WARM_DATA2COLD_DATA4Well, I don't think we need to give too many mount options for this fragmented case. How about doing this for the large files only like this?
Thread A write 512 pages Thread B write 8 pages
-
writepages()
-mutex_lock(&sbi->writepages);
-writepage();
...
-writepages()
-writepage()
....
-writepage();
...
-mutex_unlock(&sbi->writepages);
Quoted 4 lines
Above case will also cause fragmentation since we didn't serialize all concurrent IO with the lock.
Do we need to consider such case?
We can simply allow 512 and 8 in the same segment, which would not a big deal, when considering starvation of Thread B.
Quoted 145 lines
Thanks,
Quoted 142 lines
Quoted 2 lines
From
4fea0b6e4da8512a72dd52afc7a51beb35966ad9Mon Sep 17 00:00:00 2001From: Jaegeuk Kim <[email protected]>
Date: Thu, 9 Aug 2018 17:53:34 -0700
Subject: [PATCH] f2fs: fix performance issue observed with multi-thread
sequential readThis reverts the commit - "b93f771 - f2fs: remove writepages lock" to fix the drop in sequential read throughput.
Test: ./tiotest -t 32 -d /data/tio_tmp -f 32 -b 524288 -k 1 -k 3 -L
device: UFSBefore -
read throughput: 185 MB/s
total read requests: 85177 (of these ~80000 are 4KB size requests). total write requests: 2546 (of these ~2208 requests are written in 512KB).After -
read throughput: 758 MB/s
total read requests: 2417 (of these ~2042 are 512KB reads). total write requests: 2701 (of these ~2034 requests are written in 512KB).Signed-off-by Sahitya Tummala <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>--- Documentation/ABI/testing/sysfs-fs-f2fs | 8 ++++++++ fs/f2fs/data.c | 10 ++++++++++ fs/f2fs/f2fs.h | 2 ++ fs/f2fs/segment.c | 1 + fs/f2fs/super.c | 1 + fs/f2fs/sysfs.c | 2 ++ 6 files changed, 24 insertions(+)Documentation/ABI/testing/sysfs-fs-f2fs +8
-0@@ -51,6 +51,14 @@ Description: Controls the dirty page count condition for the in-place-update policies. +What: /sys/fs/f2fs/<disk>/min_seq_blocks +Date: August 2018 +Contact: "Jaegeuk Kim" <[email protected]> +Description: + Controls the dirty page count condition for batched sequential + writes in ->writepages. + + What: /sys/fs/f2fs/<disk>/min_hot_blocks Date: March 2017 Contact: "Jaegeuk Kim" <[email protected]>fs/f2fs/data.c +10
-0@@ -2132,6 +2132,7 @@ static int __f2fs_write_data_pages(struct address_space *mapping,struct f2fs_sb_info *sbi =F2FS_I_SB (inode);struct blk_plug plug;int ret; +bool locked = false;/* deal with chardevs and other special file */ if (!mapping->a_ops->writepage)@@ -2162,10 +2163,19 @@ static int __f2fs_write_data_pages(struct address_space *mapping,else if (atomic_read (&sbi->wb_sync_req[DATA ])) goto skip_write; +if (!S_ISDIR (inode->i_mode) && +get_dirty_pages (inode) <=SM_I (sbi)->min_seq_blocks) { +mutex_lock (&sbi->writepages); + locked = true; + } +blk_start_plug (&plug); ret =f2fs_write_cache_pages (mapping, wbc, io_type);blk_finish_plug (&plug); +if (locked) +mutex_unlock (&sbi->writepages); +if (wbc->sync_mode ==WB_SYNC_ALL )atomic_dec (&sbi->wb_sync_req[DATA ]);/* fs/f2fs/f2fs.h +2
-0@@ -913,6 +913,7 @@ struct f2fs_sm_info {unsigned int ipu_policy;/* in-place-update policy */ unsigned int min_ipu_util;/* in-place-update threshold */ unsigned int min_fsync_blocks;/* threshold for fsync */ +unsigned int min_seq_blocks;/* threshold for sequential blocks */ unsigned int min_hot_blocks;/* threshold for hot block allocation */ unsigned int min_ssr_sections;/* threshold to trigger SSR allocation */ @@ -1133,6 +1134,7 @@ struct f2fs_sb_info {struct rw_semaphore sb_lock;/* lock for raw super block */ int valid_super_block;/* valid super block no */ unsigned long s_flag;/* flags for sbi */ +struct mutex writepages;/* mutex for writepages() */ #ifdef CONFIG_BLK_DEV_ZONED unsigned int blocks_per_blkz;/* F2FS blocks per zone */ fs/f2fs/segment.c +1
-0@@ -4131,6 +4131,7 @@ int f2fs_build_segment_manager(struct f2fs_sb_info *sbi) sm_info->ipu_policy =1 <<F2FS_IPU_FSYNC ; sm_info->min_ipu_util =DEF_MIN_IPU_UTIL ; sm_info->min_fsync_blocks =DEF_MIN_FSYNC_BLOCKS ; + sm_info->min_seq_blocks = sbi->blocks_per_seg * sbi->segs_per_sec; sm_info->min_hot_blocks =DEF_MIN_HOT_BLOCKS ; sm_info->min_ssr_sections =reserved_sections (sbi);fs/f2fs/super.c +1
-0@@ -2842,6 +2842,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)/* init f2fs-specific super block info */ sbi->valid_super_block = valid_super_block;mutex_init (&sbi->gc_mutex); +mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);fs/f2fs/sysfs.c +1
-0@@ -397,6 +397,7 @@ F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, batched_trim_sections, trim_sections);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, ipu_policy, ipu_policy);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_ipu_util, min_ipu_util);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_fsync_blocks, min_fsync_blocks); +F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_seq_blocks, min_seq_blocks);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_hot_blocks, min_hot_blocks);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_ssr_sections, min_ssr_sections);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ram_thresh, ram_thresh);@@ -449,6 +450,7 @@ static struct attribute *f2fs_attrs[] = {
Quoted 8 lines
fs/f2fs/sysfs.c static struct attribute *f2fs_attrs[] = { · line 456
Quoted 8 lines
fs/f2fs/sysfs.c +1
-0ATTR_LIST (ipu_policy),ATTR_LIST (min_ipu_util),ATTR_LIST (min_fsync_blocks), +ATTR_LIST (min_seq_blocks),ATTR_LIST (min_hot_blocks),ATTR_LIST (min_ssr_sections), ATTR_LIST(max_victim_search),
------------------------------------------------------------------------------
Check out the vibrant tech community on one of the world's most engaging tech sites, Slashdot.org! http://sdm.link/slashdot
Quoted 51 lines · Jaegeuk Kim
Quoted 50 lines · Chao Yu
Quoted 27 lines · Jaegeuk Kim
Quoted 26 lines · Chao Yu
Hi Jaegeuk,
Quoted 11 lines · Jaegeuk Kim
This reverts the commit - "b93f771 - f2fs: remove writepages lock" to fix the drop in sequential read throughput.
Test: ./tiotest -t 32 -d /data/tio_tmp -f 32 -b 524288 -k 1 -k 3 -L
device: UFSBefore -
read throughput: 185 MB/s
total read requests: 85177 (of these ~80000 are 4KB size requests). total write requests: 2546 (of these ~2208 requests are written in 512KB).Quoted 4 lines
After -
read throughput: 758 MB/s
total read requests: 2417 (of these ~2042 are 512KB reads). total write requests: 2701 (of these ~2034 requests are written in 512KB).IMO, it only impact sequential read performance in a large file which may be fragmented during multi-thread writing.
In android environment, mostly, the large file should be cold type, such as apk, mp3, rmvb, jpeg..., so I think we only need to serialize
writepages()for cold data area writer.Quoted 8 lines
Quoted 5 lines
So how about adding a mount option to serialize
writepage()for different type of log, e.g. in android, using serialize=4; by default, using serialize=7HOT_DATA1WARM_DATA2COLD_DATA4Well, I don't think we need to give too many mount options for this fragmented case. How about doing this for the large files only like this?
Thread A write 512 pages Thread B write 8 pages
-
writepages()
-mutex_lock(&sbi->writepages);
-writepage();
...
-writepages()
-writepage()
....
-writepage();
...
-mutex_unlock(&sbi->writepages);
Quoted 7 lines
Quoted 4 lines
Above case will also cause fragmentation since we didn't serialize all concurrent IO with the lock.
Do we need to consider such case?
We can simply allow 512 and 8 in the same segment, which would not a big deal, when considering starvation of Thread B.
Yeah, but in reality, there would be more threads competing in same log header, so I worry that the effect of defragmenting will not so good as we expect, anyway, for benchmark, it's enough.
Thanks,
Quoted 157 lines
Quoted 146 lines
Thanks,
Quoted 142 lines
Quoted 2 lines
From
4fea0b6e4da8512a72dd52afc7a51beb35966ad9Mon Sep 17 00:00:00 2001From: Jaegeuk Kim <[email protected]>
Date: Thu, 9 Aug 2018 17:53:34 -0700
Subject: [PATCH] f2fs: fix performance issue observed with multi-thread
sequential readThis reverts the commit - "b93f771 - f2fs: remove writepages lock" to fix the drop in sequential read throughput.
Test: ./tiotest -t 32 -d /data/tio_tmp -f 32 -b 524288 -k 1 -k 3 -L
device: UFSBefore -
read throughput: 185 MB/s
total read requests: 85177 (of these ~80000 are 4KB size requests). total write requests: 2546 (of these ~2208 requests are written in 512KB).After -
read throughput: 758 MB/s
total read requests: 2417 (of these ~2042 are 512KB reads). total write requests: 2701 (of these ~2034 requests are written in 512KB).Signed-off-by Sahitya Tummala <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>--- Documentation/ABI/testing/sysfs-fs-f2fs | 8 ++++++++ fs/f2fs/data.c | 10 ++++++++++ fs/f2fs/f2fs.h | 2 ++ fs/f2fs/segment.c | 1 + fs/f2fs/super.c | 1 + fs/f2fs/sysfs.c | 2 ++ 6 files changed, 24 insertions(+)Documentation/ABI/testing/sysfs-fs-f2fs +8
-0@@ -51,6 +51,14 @@ Description: Controls the dirty page count condition for the in-place-update policies. +What: /sys/fs/f2fs/<disk>/min_seq_blocks +Date: August 2018 +Contact: "Jaegeuk Kim" <[email protected]> +Description: + Controls the dirty page count condition for batched sequential + writes in ->writepages. + + What: /sys/fs/f2fs/<disk>/min_hot_blocks Date: March 2017 Contact: "Jaegeuk Kim" <[email protected]>fs/f2fs/data.c +10
-0@@ -2132,6 +2132,7 @@ static int __f2fs_write_data_pages(struct address_space *mapping,struct f2fs_sb_info *sbi =F2FS_I_SB (inode);struct blk_plug plug;int ret; +bool locked = false;/* deal with chardevs and other special file */ if (!mapping->a_ops->writepage)@@ -2162,10 +2163,19 @@ static int __f2fs_write_data_pages(struct address_space *mapping,else if (atomic_read (&sbi->wb_sync_req[DATA ])) goto skip_write; +if (!S_ISDIR (inode->i_mode) && +get_dirty_pages (inode) <=SM_I (sbi)->min_seq_blocks) { +mutex_lock (&sbi->writepages); + locked = true; + } +blk_start_plug (&plug); ret =f2fs_write_cache_pages (mapping, wbc, io_type);blk_finish_plug (&plug); +if (locked) +mutex_unlock (&sbi->writepages); +if (wbc->sync_mode ==WB_SYNC_ALL )atomic_dec (&sbi->wb_sync_req[DATA ]);/* fs/f2fs/f2fs.h +2
-0@@ -913,6 +913,7 @@ struct f2fs_sm_info {unsigned int ipu_policy;/* in-place-update policy */ unsigned int min_ipu_util;/* in-place-update threshold */ unsigned int min_fsync_blocks;/* threshold for fsync */ +unsigned int min_seq_blocks;/* threshold for sequential blocks */ unsigned int min_hot_blocks;/* threshold for hot block allocation */ unsigned int min_ssr_sections;/* threshold to trigger SSR allocation */ @@ -1133,6 +1134,7 @@ struct f2fs_sb_info {struct rw_semaphore sb_lock;/* lock for raw super block */ int valid_super_block;/* valid super block no */ unsigned long s_flag;/* flags for sbi */ +struct mutex writepages;/* mutex for writepages() */ #ifdef CONFIG_BLK_DEV_ZONED unsigned int blocks_per_blkz;/* F2FS blocks per zone */ fs/f2fs/segment.c +1
-0@@ -4131,6 +4131,7 @@ int f2fs_build_segment_manager(struct f2fs_sb_info *sbi) sm_info->ipu_policy =1 <<F2FS_IPU_FSYNC ; sm_info->min_ipu_util =DEF_MIN_IPU_UTIL ; sm_info->min_fsync_blocks =DEF_MIN_FSYNC_BLOCKS ; + sm_info->min_seq_blocks = sbi->blocks_per_seg * sbi->segs_per_sec; sm_info->min_hot_blocks =DEF_MIN_HOT_BLOCKS ; sm_info->min_ssr_sections =reserved_sections (sbi);fs/f2fs/super.c +1
-0@@ -2842,6 +2842,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)/* init f2fs-specific super block info */ sbi->valid_super_block = valid_super_block;mutex_init (&sbi->gc_mutex); +mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);fs/f2fs/sysfs.c +1
-0@@ -397,6 +397,7 @@ F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, batched_trim_sections, trim_sections);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, ipu_policy, ipu_policy);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_ipu_util, min_ipu_util);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_fsync_blocks, min_fsync_blocks); +F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_seq_blocks, min_seq_blocks);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_hot_blocks, min_hot_blocks);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_ssr_sections, min_ssr_sections);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ram_thresh, ram_thresh);@@ -449,6 +450,7 @@ static struct attribute *f2fs_attrs[] = {Quoted 8 lines
fs/f2fs/sysfs.c static struct attribute *f2fs_attrs[] = { · line 456
Quoted 8 lines
fs/f2fs/sysfs.c +1
-0ATTR_LIST (ipu_policy),ATTR_LIST (min_ipu_util),ATTR_LIST (min_fsync_blocks), +ATTR_LIST (min_seq_blocks),ATTR_LIST (min_hot_blocks),ATTR_LIST (min_ssr_sections), ATTR_LIST(max_victim_search),.
Jaegeuk Kim
maintainerQuoted 55 lines · Chao Yu
Quoted 54 lines · Jaegeuk Kim
Quoted 53 lines · Chao Yu
Quoted 27 lines · Jaegeuk Kim
Quoted 26 lines · Chao Yu
Hi Jaegeuk,
Quoted 11 lines · Jaegeuk Kim
This reverts the commit - "b93f771 - f2fs: remove writepages lock" to fix the drop in sequential read throughput.
Test: ./tiotest -t 32 -d /data/tio_tmp -f 32 -b 524288 -k 1 -k 3 -L
device: UFSBefore -
read throughput: 185 MB/s
total read requests: 85177 (of these ~80000 are 4KB size requests). total write requests: 2546 (of these ~2208 requests are written in 512KB).Quoted 4 lines
After -
read throughput: 758 MB/s
total read requests: 2417 (of these ~2042 are 512KB reads). total write requests: 2701 (of these ~2034 requests are written in 512KB).IMO, it only impact sequential read performance in a large file which may be fragmented during multi-thread writing.
In android environment, mostly, the large file should be cold type, such as apk, mp3, rmvb, jpeg..., so I think we only need to serialize
writepages()for cold data area writer.Quoted 8 lines
Quoted 5 lines
So how about adding a mount option to serialize
writepage()for different type of log, e.g. in android, using serialize=4; by default, using serialize=7HOT_DATA1WARM_DATA2COLD_DATA4Well, I don't think we need to give too many mount options for this fragmented case. How about doing this for the large files only like this?
Thread A write 512 pages Thread B write 8 pages
-
writepages()
-mutex_lock(&sbi->writepages);
-writepage();
...
-writepages()
-writepage()
....
-writepage();
...
-mutex_unlock(&sbi->writepages);Above case will also cause fragmentation since we didn't serialize all concurrent IO with the lock.
Quoted 8 lines
Quoted 4 lines
Quoted 1 line
Do we need to consider such case?
We can simply allow 512 and 8 in the same segment, which would not a big deal, when considering starvation of Thread B.
Yeah, but in reality, there would be more threads competing in same log header, so I worry that the effect of defragmenting will not so good as we expect, anyway, for benchmark, it's enough.
Basically, I think this is not a benchmark issue. :) It just reveals the issue much easily. Let me think about three cases:
1) WB_SYNC_NONE & WB_SYNC_NONE
-> can simply use mutex_lock
2) WB_SYNC_ALL & WB_SYNC_NONE
-> can use mutex_lock on WB_SYNC_ALL having >512 blocks, while WB_SYNC_NONE
will skip writing blocks
3) WB_SYNC_ALL & WB_SYNC_ALL
-> can use mutex_lock on WB_SYNC_ALL having >512 blocks, in order to avoid
starvation.
I've been testing the below.
if (!S_ISDIR(inode->i_mode) && (wbc->sync_mode != WB_SYNC_ALL ||
get_dirty_pages(inode) <= SM_I(sbi)->min_seq_blocks)) {
mutex_lock(&sbi->writepages);
locked = true;
}Thanks,
Quoted 160 lines
Thanks,
Quoted 157 lines
Quoted 146 lines
Thanks,
Quoted 142 lines
Quoted 2 lines
From
4fea0b6e4da8512a72dd52afc7a51beb35966ad9Mon Sep 17 00:00:00 2001From: Jaegeuk Kim <[email protected]>
Date: Thu, 9 Aug 2018 17:53:34 -0700
Subject: [PATCH] f2fs: fix performance issue observed with multi-thread
sequential readThis reverts the commit - "b93f771 - f2fs: remove writepages lock" to fix the drop in sequential read throughput.
Test: ./tiotest -t 32 -d /data/tio_tmp -f 32 -b 524288 -k 1 -k 3 -L
device: UFSBefore -
read throughput: 185 MB/s
total read requests: 85177 (of these ~80000 are 4KB size requests). total write requests: 2546 (of these ~2208 requests are written in 512KB).After -
read throughput: 758 MB/s
total read requests: 2417 (of these ~2042 are 512KB reads). total write requests: 2701 (of these ~2034 requests are written in 512KB).Signed-off-by Sahitya Tummala <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>--- Documentation/ABI/testing/sysfs-fs-f2fs | 8 ++++++++ fs/f2fs/data.c | 10 ++++++++++ fs/f2fs/f2fs.h | 2 ++ fs/f2fs/segment.c | 1 + fs/f2fs/super.c | 1 + fs/f2fs/sysfs.c | 2 ++ 6 files changed, 24 insertions(+)Documentation/ABI/testing/sysfs-fs-f2fs +8
-0@@ -51,6 +51,14 @@ Description: Controls the dirty page count condition for the in-place-update policies. +What: /sys/fs/f2fs/<disk>/min_seq_blocks +Date: August 2018 +Contact: "Jaegeuk Kim" <[email protected]> +Description: + Controls the dirty page count condition for batched sequential + writes in ->writepages. + + What: /sys/fs/f2fs/<disk>/min_hot_blocks Date: March 2017 Contact: "Jaegeuk Kim" <[email protected]>fs/f2fs/data.c +10
-0@@ -2132,6 +2132,7 @@ static int __f2fs_write_data_pages(struct address_space *mapping,struct f2fs_sb_info *sbi =F2FS_I_SB (inode);struct blk_plug plug;int ret; +bool locked = false;/* deal with chardevs and other special file */ if (!mapping->a_ops->writepage)@@ -2162,10 +2163,19 @@ static int __f2fs_write_data_pages(struct address_space *mapping,else if (atomic_read (&sbi->wb_sync_req[DATA ])) goto skip_write; +if (!S_ISDIR (inode->i_mode) && +get_dirty_pages (inode) <=SM_I (sbi)->min_seq_blocks) { +mutex_lock (&sbi->writepages); + locked = true; + } +blk_start_plug (&plug); ret =f2fs_write_cache_pages (mapping, wbc, io_type);blk_finish_plug (&plug); +if (locked) +mutex_unlock (&sbi->writepages); +if (wbc->sync_mode ==WB_SYNC_ALL )atomic_dec (&sbi->wb_sync_req[DATA ]);/* fs/f2fs/f2fs.h +2
-0@@ -913,6 +913,7 @@ struct f2fs_sm_info {unsigned int ipu_policy;/* in-place-update policy */ unsigned int min_ipu_util;/* in-place-update threshold */ unsigned int min_fsync_blocks;/* threshold for fsync */ +unsigned int min_seq_blocks;/* threshold for sequential blocks */ unsigned int min_hot_blocks;/* threshold for hot block allocation */ unsigned int min_ssr_sections;/* threshold to trigger SSR allocation */ @@ -1133,6 +1134,7 @@ struct f2fs_sb_info {struct rw_semaphore sb_lock;/* lock for raw super block */ int valid_super_block;/* valid super block no */ unsigned long s_flag;/* flags for sbi */ +struct mutex writepages;/* mutex for writepages() */ #ifdef CONFIG_BLK_DEV_ZONED unsigned int blocks_per_blkz;/* F2FS blocks per zone */ fs/f2fs/segment.c +1
-0@@ -4131,6 +4131,7 @@ int f2fs_build_segment_manager(struct f2fs_sb_info *sbi) sm_info->ipu_policy =1 <<F2FS_IPU_FSYNC ; sm_info->min_ipu_util =DEF_MIN_IPU_UTIL ; sm_info->min_fsync_blocks =DEF_MIN_FSYNC_BLOCKS ; + sm_info->min_seq_blocks = sbi->blocks_per_seg * sbi->segs_per_sec; sm_info->min_hot_blocks =DEF_MIN_HOT_BLOCKS ; sm_info->min_ssr_sections =reserved_sections (sbi);fs/f2fs/super.c +1
-0@@ -2842,6 +2842,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)/* init f2fs-specific super block info */ sbi->valid_super_block = valid_super_block;mutex_init (&sbi->gc_mutex); +mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);fs/f2fs/sysfs.c +1
-0@@ -397,6 +397,7 @@ F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, batched_trim_sections, trim_sections);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, ipu_policy, ipu_policy);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_ipu_util, min_ipu_util);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_fsync_blocks, min_fsync_blocks); +F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_seq_blocks, min_seq_blocks);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_hot_blocks, min_hot_blocks);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_ssr_sections, min_ssr_sections);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ram_thresh, ram_thresh);@@ -449,6 +450,7 @@ static struct attribute *f2fs_attrs[] = {Quoted 8 lines
fs/f2fs/sysfs.c static struct attribute *f2fs_attrs[] = { · line 456
Quoted 8 lines
fs/f2fs/sysfs.c +1
-0ATTR_LIST (ipu_policy),ATTR_LIST (min_ipu_util),ATTR_LIST (min_fsync_blocks), +ATTR_LIST (min_seq_blocks),ATTR_LIST (min_hot_blocks),ATTR_LIST (min_ssr_sections), ATTR_LIST(max_victim_search),.
Quoted 79 lines · Jaegeuk Kim
Quoted 55 lines · Chao Yu
Quoted 54 lines · Jaegeuk Kim
Quoted 53 lines · Chao Yu
Quoted 27 lines · Jaegeuk Kim
Quoted 26 lines · Chao Yu
Hi Jaegeuk,
Quoted 11 lines · Jaegeuk Kim
This reverts the commit - "b93f771 - f2fs: remove writepages lock" to fix the drop in sequential read throughput.
Test: ./tiotest -t 32 -d /data/tio_tmp -f 32 -b 524288 -k 1 -k 3 -L
device: UFSBefore -
read throughput: 185 MB/s
total read requests: 85177 (of these ~80000 are 4KB size requests). total write requests: 2546 (of these ~2208 requests are written in 512KB).Quoted 4 lines
After -
read throughput: 758 MB/s
total read requests: 2417 (of these ~2042 are 512KB reads). total write requests: 2701 (of these ~2034 requests are written in 512KB).IMO, it only impact sequential read performance in a large file which may be fragmented during multi-thread writing.
In android environment, mostly, the large file should be cold type, such as apk, mp3, rmvb, jpeg..., so I think we only need to serialize
writepages()for cold data area writer.Quoted 8 lines
Quoted 5 lines
So how about adding a mount option to serialize
writepage()for different type of log, e.g. in android, using serialize=4; by default, using serialize=7HOT_DATA1WARM_DATA2COLD_DATA4Well, I don't think we need to give too many mount options for this fragmented case. How about doing this for the large files only like this?
Thread A write 512 pages Thread B write 8 pages
-
writepages()
-mutex_lock(&sbi->writepages);
-writepage();
...
-writepages()
-writepage()
....
-writepage();
...
-mutex_unlock(&sbi->writepages);Above case will also cause fragmentation since we didn't serialize all concurrent IO with the lock.
Quoted 8 lines
Quoted 4 lines
Quoted 1 line
Do we need to consider such case?
We can simply allow 512 and 8 in the same segment, which would not a big deal, when considering starvation of Thread B.
Yeah, but in reality, there would be more threads competing in same log header, so I worry that the effect of defragmenting will not so good as we expect, anyway, for benchmark, it's enough.
Basically, I think this is not a benchmark issue. :) It just reveals the issue much easily. Let me think about three cases:
1)WB_SYNC_NONE&WB_SYNC_NONE
-> can simply usemutex_lock2)
WB_SYNC_ALL&WB_SYNC_NONE
-> can usemutex_lockonWB_SYNC_ALLhaving >512 blocks, whileWB_SYNC_NONE
will skip writing blocks3)
WB_SYNC_ALL&WB_SYNC_ALL
-> can usemutex_lockonWB_SYNC_ALLhaving >512 blocks, in order to avoid
starvation.
Quoted 6 lines
I've been testing the below.
if (!S_ISDIR(inode->i_mode) && (
wbc->sync_mode!=WB_SYNC_ALL||get_dirty_pages(inode) <= SM_I(sbi)->min_seq_blocks)) { mutex_lock(&sbi->writepages); locked = true;
Just cover buffered IO? how about covering Direct IO and atomic write as well?
Thanks,
Quoted 167 lines
}
Thanks,
Quoted 160 lines
Thanks,
Quoted 157 lines
Quoted 146 lines
Thanks,
Quoted 142 lines
Quoted 2 lines
From
4fea0b6e4da8512a72dd52afc7a51beb35966ad9Mon Sep 17 00:00:00 2001From: Jaegeuk Kim <[email protected]>
Date: Thu, 9 Aug 2018 17:53:34 -0700
Subject: [PATCH] f2fs: fix performance issue observed with multi-thread
sequential readThis reverts the commit - "b93f771 - f2fs: remove writepages lock" to fix the drop in sequential read throughput.
Test: ./tiotest -t 32 -d /data/tio_tmp -f 32 -b 524288 -k 1 -k 3 -L
device: UFSBefore -
read throughput: 185 MB/s
total read requests: 85177 (of these ~80000 are 4KB size requests). total write requests: 2546 (of these ~2208 requests are written in 512KB).After -
read throughput: 758 MB/s
total read requests: 2417 (of these ~2042 are 512KB reads). total write requests: 2701 (of these ~2034 requests are written in 512KB).Signed-off-by Sahitya Tummala <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>--- Documentation/ABI/testing/sysfs-fs-f2fs | 8 ++++++++ fs/f2fs/data.c | 10 ++++++++++ fs/f2fs/f2fs.h | 2 ++ fs/f2fs/segment.c | 1 + fs/f2fs/super.c | 1 + fs/f2fs/sysfs.c | 2 ++ 6 files changed, 24 insertions(+)Documentation/ABI/testing/sysfs-fs-f2fs +8
-0@@ -51,6 +51,14 @@ Description: Controls the dirty page count condition for the in-place-update policies. +What: /sys/fs/f2fs/<disk>/min_seq_blocks +Date: August 2018 +Contact: "Jaegeuk Kim" <[email protected]> +Description: + Controls the dirty page count condition for batched sequential + writes in ->writepages. + + What: /sys/fs/f2fs/<disk>/min_hot_blocks Date: March 2017 Contact: "Jaegeuk Kim" <[email protected]>fs/f2fs/data.c +10
-0@@ -2132,6 +2132,7 @@ static int __f2fs_write_data_pages(struct address_space *mapping,struct f2fs_sb_info *sbi =F2FS_I_SB (inode);struct blk_plug plug;int ret; +bool locked = false;/* deal with chardevs and other special file */ if (!mapping->a_ops->writepage)@@ -2162,10 +2163,19 @@ static int __f2fs_write_data_pages(struct address_space *mapping,else if (atomic_read (&sbi->wb_sync_req[DATA ])) goto skip_write; +if (!S_ISDIR (inode->i_mode) && +get_dirty_pages (inode) <=SM_I (sbi)->min_seq_blocks) { +mutex_lock (&sbi->writepages); + locked = true; + } +blk_start_plug (&plug); ret =f2fs_write_cache_pages (mapping, wbc, io_type);blk_finish_plug (&plug); +if (locked) +mutex_unlock (&sbi->writepages); +if (wbc->sync_mode ==WB_SYNC_ALL )atomic_dec (&sbi->wb_sync_req[DATA ]);/* fs/f2fs/f2fs.h +2
-0@@ -913,6 +913,7 @@ struct f2fs_sm_info {unsigned int ipu_policy;/* in-place-update policy */ unsigned int min_ipu_util;/* in-place-update threshold */ unsigned int min_fsync_blocks;/* threshold for fsync */ +unsigned int min_seq_blocks;/* threshold for sequential blocks */ unsigned int min_hot_blocks;/* threshold for hot block allocation */ unsigned int min_ssr_sections;/* threshold to trigger SSR allocation */ @@ -1133,6 +1134,7 @@ struct f2fs_sb_info {struct rw_semaphore sb_lock;/* lock for raw super block */ int valid_super_block;/* valid super block no */ unsigned long s_flag;/* flags for sbi */ +struct mutex writepages;/* mutex for writepages() */ #ifdef CONFIG_BLK_DEV_ZONED unsigned int blocks_per_blkz;/* F2FS blocks per zone */ fs/f2fs/segment.c +1
-0@@ -4131,6 +4131,7 @@ int f2fs_build_segment_manager(struct f2fs_sb_info *sbi) sm_info->ipu_policy =1 <<F2FS_IPU_FSYNC ; sm_info->min_ipu_util =DEF_MIN_IPU_UTIL ; sm_info->min_fsync_blocks =DEF_MIN_FSYNC_BLOCKS ; + sm_info->min_seq_blocks = sbi->blocks_per_seg * sbi->segs_per_sec; sm_info->min_hot_blocks =DEF_MIN_HOT_BLOCKS ; sm_info->min_ssr_sections =reserved_sections (sbi);fs/f2fs/super.c +1
-0@@ -2842,6 +2842,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)/* init f2fs-specific super block info */ sbi->valid_super_block = valid_super_block;mutex_init (&sbi->gc_mutex); +mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);fs/f2fs/sysfs.c +1
-0@@ -397,6 +397,7 @@ F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, batched_trim_sections, trim_sections);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, ipu_policy, ipu_policy);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_ipu_util, min_ipu_util);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_fsync_blocks, min_fsync_blocks); +F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_seq_blocks, min_seq_blocks);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_hot_blocks, min_hot_blocks);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_ssr_sections, min_ssr_sections);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ram_thresh, ram_thresh);@@ -449,6 +450,7 @@ static struct attribute *f2fs_attrs[] = {Quoted 8 lines
fs/f2fs/sysfs.c static struct attribute *f2fs_attrs[] = { · line 456
Quoted 8 lines
fs/f2fs/sysfs.c +1
-0ATTR_LIST (ipu_policy),ATTR_LIST (min_ipu_util),ATTR_LIST (min_fsync_blocks), +ATTR_LIST (min_seq_blocks),ATTR_LIST (min_hot_blocks),ATTR_LIST (min_ssr_sections), ATTR_LIST(max_victim_search),.
.
Jaegeuk Kim
maintainerQuoted 80 lines · Chao Yu
Quoted 79 lines · Jaegeuk Kim
Quoted 55 lines · Chao Yu
Quoted 54 lines · Jaegeuk Kim
Quoted 53 lines · Chao Yu
Quoted 27 lines · Jaegeuk Kim
Quoted 26 lines · Chao Yu
Hi Jaegeuk,
Quoted 11 lines · Jaegeuk Kim
This reverts the commit - "b93f771 - f2fs: remove writepages lock" to fix the drop in sequential read throughput.
Test: ./tiotest -t 32 -d /data/tio_tmp -f 32 -b 524288 -k 1 -k 3 -L
device: UFSBefore -
read throughput: 185 MB/s
total read requests: 85177 (of these ~80000 are 4KB size requests). total write requests: 2546 (of these ~2208 requests are written in 512KB).Quoted 4 lines
After -
read throughput: 758 MB/s
total read requests: 2417 (of these ~2042 are 512KB reads). total write requests: 2701 (of these ~2034 requests are written in 512KB).IMO, it only impact sequential read performance in a large file which may be fragmented during multi-thread writing.
In android environment, mostly, the large file should be cold type, such as apk, mp3, rmvb, jpeg..., so I think we only need to serialize
writepages()for cold data area writer.Quoted 8 lines
Quoted 5 lines
So how about adding a mount option to serialize
writepage()for different type of log, e.g. in android, using serialize=4; by default, using serialize=7HOT_DATA1WARM_DATA2COLD_DATA4Well, I don't think we need to give too many mount options for this fragmented case. How about doing this for the large files only like this?
Thread A write 512 pages Thread B write 8 pages
-
writepages()
-mutex_lock(&sbi->writepages);
-writepage();
...
-writepages()
-writepage()
....
-writepage();
...
-mutex_unlock(&sbi->writepages);Above case will also cause fragmentation since we didn't serialize all concurrent IO with the lock.
Quoted 8 lines
Quoted 4 lines
Quoted 1 line
Do we need to consider such case?
We can simply allow 512 and 8 in the same segment, which would not a big deal, when considering starvation of Thread B.
Yeah, but in reality, there would be more threads competing in same log header, so I worry that the effect of defragmenting will not so good as we expect, anyway, for benchmark, it's enough.
Basically, I think this is not a benchmark issue. :) It just reveals the issue much easily. Let me think about three cases:
1)WB_SYNC_NONE&WB_SYNC_NONE
-> can simply usemutex_lock2)
WB_SYNC_ALL&WB_SYNC_NONE
-> can usemutex_lockonWB_SYNC_ALLhaving >512 blocks, whileWB_SYNC_NONE
will skip writing blocks3)
WB_SYNC_ALL&WB_SYNC_ALL
-> can usemutex_lockonWB_SYNC_ALLhaving >512 blocks, in order to avoid
starvation.
Quoted 8 lines
Quoted 6 lines
I've been testing the below.
if (!S_ISDIR(inode->i_mode) && (
wbc->sync_mode!=WB_SYNC_ALL||get_dirty_pages(inode) <= SM_I(sbi)->min_seq_blocks)) { mutex_lock(&sbi->writepages); locked = true;Just cover buffered IO? how about covering Direct IO and atomic write as well?
I'd expect direct IO does in-place-updates, and not sure whether we need to add another lock contention between buffered or direct IO. Atomic writes would be covered by ->min_seq_blocks.
Quoted 170 lines
Thanks,
Quoted 167 lines
}
Thanks,
Quoted 160 lines
Thanks,
Quoted 157 lines
Quoted 146 lines
Thanks,
Quoted 142 lines
Quoted 2 lines
From
4fea0b6e4da8512a72dd52afc7a51beb35966ad9Mon Sep 17 00:00:00 2001From: Jaegeuk Kim <[email protected]>
Date: Thu, 9 Aug 2018 17:53:34 -0700
Subject: [PATCH] f2fs: fix performance issue observed with multi-thread
sequential readThis reverts the commit - "b93f771 - f2fs: remove writepages lock" to fix the drop in sequential read throughput.
Test: ./tiotest -t 32 -d /data/tio_tmp -f 32 -b 524288 -k 1 -k 3 -L
device: UFSBefore -
read throughput: 185 MB/s
total read requests: 85177 (of these ~80000 are 4KB size requests). total write requests: 2546 (of these ~2208 requests are written in 512KB).After -
read throughput: 758 MB/s
total read requests: 2417 (of these ~2042 are 512KB reads). total write requests: 2701 (of these ~2034 requests are written in 512KB).Signed-off-by Sahitya Tummala <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>--- Documentation/ABI/testing/sysfs-fs-f2fs | 8 ++++++++ fs/f2fs/data.c | 10 ++++++++++ fs/f2fs/f2fs.h | 2 ++ fs/f2fs/segment.c | 1 + fs/f2fs/super.c | 1 + fs/f2fs/sysfs.c | 2 ++ 6 files changed, 24 insertions(+)Documentation/ABI/testing/sysfs-fs-f2fs +8
-0@@ -51,6 +51,14 @@ Description: Controls the dirty page count condition for the in-place-update policies. +What: /sys/fs/f2fs/<disk>/min_seq_blocks +Date: August 2018 +Contact: "Jaegeuk Kim" <[email protected]> +Description: + Controls the dirty page count condition for batched sequential + writes in ->writepages. + + What: /sys/fs/f2fs/<disk>/min_hot_blocks Date: March 2017 Contact: "Jaegeuk Kim" <[email protected]>fs/f2fs/data.c +10
-0@@ -2132,6 +2132,7 @@ static int __f2fs_write_data_pages(struct address_space *mapping,struct f2fs_sb_info *sbi =F2FS_I_SB (inode);struct blk_plug plug;int ret; +bool locked = false;/* deal with chardevs and other special file */ if (!mapping->a_ops->writepage)@@ -2162,10 +2163,19 @@ static int __f2fs_write_data_pages(struct address_space *mapping,else if (atomic_read (&sbi->wb_sync_req[DATA ])) goto skip_write; +if (!S_ISDIR (inode->i_mode) && +get_dirty_pages (inode) <=SM_I (sbi)->min_seq_blocks) { +mutex_lock (&sbi->writepages); + locked = true; + } +blk_start_plug (&plug); ret =f2fs_write_cache_pages (mapping, wbc, io_type);blk_finish_plug (&plug); +if (locked) +mutex_unlock (&sbi->writepages); +if (wbc->sync_mode ==WB_SYNC_ALL )atomic_dec (&sbi->wb_sync_req[DATA ]);/* fs/f2fs/f2fs.h +2
-0@@ -913,6 +913,7 @@ struct f2fs_sm_info {unsigned int ipu_policy;/* in-place-update policy */ unsigned int min_ipu_util;/* in-place-update threshold */ unsigned int min_fsync_blocks;/* threshold for fsync */ +unsigned int min_seq_blocks;/* threshold for sequential blocks */ unsigned int min_hot_blocks;/* threshold for hot block allocation */ unsigned int min_ssr_sections;/* threshold to trigger SSR allocation */ @@ -1133,6 +1134,7 @@ struct f2fs_sb_info {struct rw_semaphore sb_lock;/* lock for raw super block */ int valid_super_block;/* valid super block no */ unsigned long s_flag;/* flags for sbi */ +struct mutex writepages;/* mutex for writepages() */ #ifdef CONFIG_BLK_DEV_ZONED unsigned int blocks_per_blkz;/* F2FS blocks per zone */ fs/f2fs/segment.c +1
-0@@ -4131,6 +4131,7 @@ int f2fs_build_segment_manager(struct f2fs_sb_info *sbi) sm_info->ipu_policy =1 <<F2FS_IPU_FSYNC ; sm_info->min_ipu_util =DEF_MIN_IPU_UTIL ; sm_info->min_fsync_blocks =DEF_MIN_FSYNC_BLOCKS ; + sm_info->min_seq_blocks = sbi->blocks_per_seg * sbi->segs_per_sec; sm_info->min_hot_blocks =DEF_MIN_HOT_BLOCKS ; sm_info->min_ssr_sections =reserved_sections (sbi);fs/f2fs/super.c +1
-0@@ -2842,6 +2842,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)/* init f2fs-specific super block info */ sbi->valid_super_block = valid_super_block;mutex_init (&sbi->gc_mutex); +mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);fs/f2fs/sysfs.c +1
-0@@ -397,6 +397,7 @@ F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, batched_trim_sections, trim_sections);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, ipu_policy, ipu_policy);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_ipu_util, min_ipu_util);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_fsync_blocks, min_fsync_blocks); +F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_seq_blocks, min_seq_blocks);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_hot_blocks, min_hot_blocks);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_ssr_sections, min_ssr_sections);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ram_thresh, ram_thresh);@@ -449,6 +450,7 @@ static struct attribute *f2fs_attrs[] = {Quoted 8 lines
fs/f2fs/sysfs.c static struct attribute *f2fs_attrs[] = { · line 456
Quoted 8 lines
fs/f2fs/sysfs.c +1
-0ATTR_LIST (ipu_policy),ATTR_LIST (min_ipu_util),ATTR_LIST (min_fsync_blocks), +ATTR_LIST (min_seq_blocks),ATTR_LIST (min_hot_blocks),ATTR_LIST (min_ssr_sections), ATTR_LIST(max_victim_search),.
.
Quoted 83 lines · Jaegeuk Kim
Quoted 82 lines · Chao Yu
Quoted 81 lines · Jaegeuk Kim
Quoted 55 lines · Chao Yu
Quoted 54 lines · Jaegeuk Kim
Quoted 53 lines · Chao Yu
Quoted 27 lines · Jaegeuk Kim
Quoted 26 lines · Chao Yu
Hi Jaegeuk,
Quoted 11 lines · Jaegeuk Kim
This reverts the commit - "b93f771 - f2fs: remove writepages lock" to fix the drop in sequential read throughput.
Test: ./tiotest -t 32 -d /data/tio_tmp -f 32 -b 524288 -k 1 -k 3 -L
device: UFSBefore -
read throughput: 185 MB/s
total read requests: 85177 (of these ~80000 are 4KB size requests). total write requests: 2546 (of these ~2208 requests are written in 512KB).Quoted 4 lines
After -
read throughput: 758 MB/s
total read requests: 2417 (of these ~2042 are 512KB reads). total write requests: 2701 (of these ~2034 requests are written in 512KB).IMO, it only impact sequential read performance in a large file which may be fragmented during multi-thread writing.
In android environment, mostly, the large file should be cold type, such as apk, mp3, rmvb, jpeg..., so I think we only need to serialize
writepages()for cold data area writer.Quoted 8 lines
Quoted 5 lines
So how about adding a mount option to serialize
writepage()for different type of log, e.g. in android, using serialize=4; by default, using serialize=7HOT_DATA1WARM_DATA2COLD_DATA4Well, I don't think we need to give too many mount options for this fragmented case. How about doing this for the large files only like this?
Thread A write 512 pages Thread B write 8 pages
-
writepages()
-mutex_lock(&sbi->writepages);
-writepage();
...
-writepages()
-writepage()
....
-writepage();
...
-mutex_unlock(&sbi->writepages);Above case will also cause fragmentation since we didn't serialize all concurrent IO with the lock.
Quoted 8 lines
Quoted 4 lines
Quoted 1 line
Do we need to consider such case?
We can simply allow 512 and 8 in the same segment, which would not a big deal, when considering starvation of Thread B.
Yeah, but in reality, there would be more threads competing in same log header, so I worry that the effect of defragmenting will not so good as we expect, anyway, for benchmark, it's enough.
Basically, I think this is not a benchmark issue. :) It just reveals the issue much easily. Let me think about three cases:
1)WB_SYNC_NONE&WB_SYNC_NONE
-> can simply usemutex_lock2)
WB_SYNC_ALL&WB_SYNC_NONE
-> can usemutex_lockonWB_SYNC_ALLhaving >512 blocks, whileWB_SYNC_NONE
will skip writing blocks3)
WB_SYNC_ALL&WB_SYNC_ALL
-> can usemutex_lockonWB_SYNC_ALLhaving >512 blocks, in order to avoid
starvation.I've been testing the below.
Quoted 8 lines
Quoted 6 lines
Quoted 4 lines
if (!S_ISDIR(inode->i_mode) && (
wbc->sync_mode!=WB_SYNC_ALL||get_dirty_pages(inode) <= SM_I(sbi)->min_seq_blocks)) { mutex_lock(&sbi->writepages); locked = true;Just cover buffered IO? how about covering Direct IO and atomic write as well?
I'd expect direct IO does in-place-updates, and not sure whether we need to
For initial writes, they are not IPU.
Quoted 2 lines
add another lock contention between buffered or direct IO. Atomic writes would be covered by ->min_seq_blocks.
Okay. :)
Thanks,
Quoted 174 lines
Quoted 171 lines
Thanks,
Quoted 167 lines
}
Thanks,
Quoted 160 lines
Thanks,
Quoted 157 lines
Quoted 146 lines
Thanks,
Quoted 142 lines
Quoted 2 lines
From
4fea0b6e4da8512a72dd52afc7a51beb35966ad9Mon Sep 17 00:00:00 2001From: Jaegeuk Kim <[email protected]>
Date: Thu, 9 Aug 2018 17:53:34 -0700
Subject: [PATCH] f2fs: fix performance issue observed with multi-thread
sequential readThis reverts the commit - "b93f771 - f2fs: remove writepages lock" to fix the drop in sequential read throughput.
Test: ./tiotest -t 32 -d /data/tio_tmp -f 32 -b 524288 -k 1 -k 3 -L
device: UFSBefore -
read throughput: 185 MB/s
total read requests: 85177 (of these ~80000 are 4KB size requests). total write requests: 2546 (of these ~2208 requests are written in 512KB).After -
read throughput: 758 MB/s
total read requests: 2417 (of these ~2042 are 512KB reads). total write requests: 2701 (of these ~2034 requests are written in 512KB).Signed-off-by Sahitya Tummala <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>--- Documentation/ABI/testing/sysfs-fs-f2fs | 8 ++++++++ fs/f2fs/data.c | 10 ++++++++++ fs/f2fs/f2fs.h | 2 ++ fs/f2fs/segment.c | 1 + fs/f2fs/super.c | 1 + fs/f2fs/sysfs.c | 2 ++ 6 files changed, 24 insertions(+)Documentation/ABI/testing/sysfs-fs-f2fs +8
-0@@ -51,6 +51,14 @@ Description: Controls the dirty page count condition for the in-place-update policies. +What: /sys/fs/f2fs/<disk>/min_seq_blocks +Date: August 2018 +Contact: "Jaegeuk Kim" <[email protected]> +Description: + Controls the dirty page count condition for batched sequential + writes in ->writepages. + + What: /sys/fs/f2fs/<disk>/min_hot_blocks Date: March 2017 Contact: "Jaegeuk Kim" <[email protected]>fs/f2fs/data.c +10
-0@@ -2132,6 +2132,7 @@ static int __f2fs_write_data_pages(struct address_space *mapping,struct f2fs_sb_info *sbi =F2FS_I_SB (inode);struct blk_plug plug;int ret; +bool locked = false;/* deal with chardevs and other special file */ if (!mapping->a_ops->writepage)@@ -2162,10 +2163,19 @@ static int __f2fs_write_data_pages(struct address_space *mapping,else if (atomic_read (&sbi->wb_sync_req[DATA ])) goto skip_write; +if (!S_ISDIR (inode->i_mode) && +get_dirty_pages (inode) <=SM_I (sbi)->min_seq_blocks) { +mutex_lock (&sbi->writepages); + locked = true; + } +blk_start_plug (&plug); ret =f2fs_write_cache_pages (mapping, wbc, io_type);blk_finish_plug (&plug); +if (locked) +mutex_unlock (&sbi->writepages); +if (wbc->sync_mode ==WB_SYNC_ALL )atomic_dec (&sbi->wb_sync_req[DATA ]);/* fs/f2fs/f2fs.h +2
-0@@ -913,6 +913,7 @@ struct f2fs_sm_info {unsigned int ipu_policy;/* in-place-update policy */ unsigned int min_ipu_util;/* in-place-update threshold */ unsigned int min_fsync_blocks;/* threshold for fsync */ +unsigned int min_seq_blocks;/* threshold for sequential blocks */ unsigned int min_hot_blocks;/* threshold for hot block allocation */ unsigned int min_ssr_sections;/* threshold to trigger SSR allocation */ @@ -1133,6 +1134,7 @@ struct f2fs_sb_info {struct rw_semaphore sb_lock;/* lock for raw super block */ int valid_super_block;/* valid super block no */ unsigned long s_flag;/* flags for sbi */ +struct mutex writepages;/* mutex for writepages() */ #ifdef CONFIG_BLK_DEV_ZONED unsigned int blocks_per_blkz;/* F2FS blocks per zone */ fs/f2fs/segment.c +1
-0@@ -4131,6 +4131,7 @@ int f2fs_build_segment_manager(struct f2fs_sb_info *sbi) sm_info->ipu_policy =1 <<F2FS_IPU_FSYNC ; sm_info->min_ipu_util =DEF_MIN_IPU_UTIL ; sm_info->min_fsync_blocks =DEF_MIN_FSYNC_BLOCKS ; + sm_info->min_seq_blocks = sbi->blocks_per_seg * sbi->segs_per_sec; sm_info->min_hot_blocks =DEF_MIN_HOT_BLOCKS ; sm_info->min_ssr_sections =reserved_sections (sbi);fs/f2fs/super.c +1
-0@@ -2842,6 +2842,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)/* init f2fs-specific super block info */ sbi->valid_super_block = valid_super_block;mutex_init (&sbi->gc_mutex); +mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);fs/f2fs/sysfs.c +1
-0@@ -397,6 +397,7 @@ F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, batched_trim_sections, trim_sections);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, ipu_policy, ipu_policy);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_ipu_util, min_ipu_util);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_fsync_blocks, min_fsync_blocks); +F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_seq_blocks, min_seq_blocks);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_hot_blocks, min_hot_blocks);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_ssr_sections, min_ssr_sections);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ram_thresh, ram_thresh);@@ -449,6 +450,7 @@ static struct attribute *f2fs_attrs[] = {Quoted 8 lines
fs/f2fs/sysfs.c static struct attribute *f2fs_attrs[] = { · line 456
Quoted 8 lines
fs/f2fs/sysfs.c +1
-0ATTR_LIST (ipu_policy),ATTR_LIST (min_ipu_util),ATTR_LIST (min_fsync_blocks), +ATTR_LIST (min_seq_blocks),ATTR_LIST (min_hot_blocks),ATTR_LIST (min_ssr_sections), ATTR_LIST(max_victim_search),.
.
.
Jaegeuk Kim
maintainerQuoted 89 lines · Chao Yu
Quoted 88 lines · Jaegeuk Kim
Quoted 87 lines · Chao Yu
Quoted 85 lines · Jaegeuk Kim
Quoted 55 lines · Chao Yu
Quoted 54 lines · Jaegeuk Kim
Quoted 53 lines · Chao Yu
Quoted 27 lines · Jaegeuk Kim
Quoted 26 lines · Chao Yu
Hi Jaegeuk,
Quoted 11 lines · Jaegeuk Kim
This reverts the commit - "b93f771 - f2fs: remove writepages lock" to fix the drop in sequential read throughput.
Test: ./tiotest -t 32 -d /data/tio_tmp -f 32 -b 524288 -k 1 -k 3 -L
device: UFSBefore -
read throughput: 185 MB/s
total read requests: 85177 (of these ~80000 are 4KB size requests). total write requests: 2546 (of these ~2208 requests are written in 512KB).Quoted 4 lines
After -
read throughput: 758 MB/s
total read requests: 2417 (of these ~2042 are 512KB reads). total write requests: 2701 (of these ~2034 requests are written in 512KB).IMO, it only impact sequential read performance in a large file which may be fragmented during multi-thread writing.
In android environment, mostly, the large file should be cold type, such as apk, mp3, rmvb, jpeg..., so I think we only need to serialize
writepages()for cold data area writer.Quoted 8 lines
Quoted 5 lines
So how about adding a mount option to serialize
writepage()for different type of log, e.g. in android, using serialize=4; by default, using serialize=7HOT_DATA1WARM_DATA2COLD_DATA4Well, I don't think we need to give too many mount options for this fragmented case. How about doing this for the large files only like this?
Thread A write 512 pages Thread B write 8 pages
-
writepages()
-mutex_lock(&sbi->writepages);
-writepage();
...
-writepages()
-writepage()
....
-writepage();
...
-mutex_unlock(&sbi->writepages);Above case will also cause fragmentation since we didn't serialize all concurrent IO with the lock.
Quoted 8 lines
Quoted 4 lines
Quoted 1 line
Do we need to consider such case?
We can simply allow 512 and 8 in the same segment, which would not a big deal, when considering starvation of Thread B.
Yeah, but in reality, there would be more threads competing in same log header, so I worry that the effect of defragmenting will not so good as we expect, anyway, for benchmark, it's enough.
Basically, I think this is not a benchmark issue. :) It just reveals the issue much easily. Let me think about three cases:
1)WB_SYNC_NONE&WB_SYNC_NONE
-> can simply usemutex_lock2)
WB_SYNC_ALL&WB_SYNC_NONE
-> can usemutex_lockonWB_SYNC_ALLhaving >512 blocks, whileWB_SYNC_NONE
will skip writing blocks3)
WB_SYNC_ALL&WB_SYNC_ALL
-> can usemutex_lockonWB_SYNC_ALLhaving >512 blocks, in order to avoid
starvation.I've been testing the below.
if (!S_ISDIR(inode->i_mode) && (
wbc->sync_mode!=WB_SYNC_ALL||get_dirty_pages(inode) <= SM_I(sbi)->min_seq_blocks)) { mutex_lock(&sbi->writepages); locked = true;
Quoted 5 lines
Quoted 3 lines
Quoted 1 line
Just cover buffered IO? how about covering Direct IO and atomic write as well?
I'd expect direct IO does in-place-updates, and not sure whether we need to
For initial writes, they are not IPU.
It's a little bit different. DIO allocates blocks first in the bulk mode, and sumbit bios later. So, it'd be more likely to allocate consecutive blocks by get_data_block_dio, if user gave a big chunk to write. I'm more concerend about lock contention, and don't think we have to serialize all the block allocation.
Quoted 182 lines
Quoted 3 lines
add another lock contention between buffered or direct IO. Atomic writes would be covered by ->min_seq_blocks.
Okay. :)
Thanks,
Quoted 174 lines
Quoted 171 lines
Thanks,
Quoted 167 lines
}
Thanks,
Quoted 160 lines
Thanks,
Quoted 157 lines
Quoted 146 lines
Thanks,
Quoted 142 lines
Quoted 2 lines
From
4fea0b6e4da8512a72dd52afc7a51beb35966ad9Mon Sep 17 00:00:00 2001From: Jaegeuk Kim <[email protected]>
Date: Thu, 9 Aug 2018 17:53:34 -0700
Subject: [PATCH] f2fs: fix performance issue observed with multi-thread
sequential readThis reverts the commit - "b93f771 - f2fs: remove writepages lock" to fix the drop in sequential read throughput.
Test: ./tiotest -t 32 -d /data/tio_tmp -f 32 -b 524288 -k 1 -k 3 -L
device: UFSBefore -
read throughput: 185 MB/s
total read requests: 85177 (of these ~80000 are 4KB size requests). total write requests: 2546 (of these ~2208 requests are written in 512KB).After -
read throughput: 758 MB/s
total read requests: 2417 (of these ~2042 are 512KB reads). total write requests: 2701 (of these ~2034 requests are written in 512KB).Signed-off-by Sahitya Tummala <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>--- Documentation/ABI/testing/sysfs-fs-f2fs | 8 ++++++++ fs/f2fs/data.c | 10 ++++++++++ fs/f2fs/f2fs.h | 2 ++ fs/f2fs/segment.c | 1 + fs/f2fs/super.c | 1 + fs/f2fs/sysfs.c | 2 ++ 6 files changed, 24 insertions(+)Documentation/ABI/testing/sysfs-fs-f2fs +8
-0@@ -51,6 +51,14 @@ Description: Controls the dirty page count condition for the in-place-update policies. +What: /sys/fs/f2fs/<disk>/min_seq_blocks +Date: August 2018 +Contact: "Jaegeuk Kim" <[email protected]> +Description: + Controls the dirty page count condition for batched sequential + writes in ->writepages. + + What: /sys/fs/f2fs/<disk>/min_hot_blocks Date: March 2017 Contact: "Jaegeuk Kim" <[email protected]>fs/f2fs/data.c +10
-0@@ -2132,6 +2132,7 @@ static int __f2fs_write_data_pages(struct address_space *mapping,struct f2fs_sb_info *sbi =F2FS_I_SB (inode);struct blk_plug plug;int ret; +bool locked = false;/* deal with chardevs and other special file */ if (!mapping->a_ops->writepage)@@ -2162,10 +2163,19 @@ static int __f2fs_write_data_pages(struct address_space *mapping,else if (atomic_read (&sbi->wb_sync_req[DATA ])) goto skip_write; +if (!S_ISDIR (inode->i_mode) && +get_dirty_pages (inode) <=SM_I (sbi)->min_seq_blocks) { +mutex_lock (&sbi->writepages); + locked = true; + } +blk_start_plug (&plug); ret =f2fs_write_cache_pages (mapping, wbc, io_type);blk_finish_plug (&plug); +if (locked) +mutex_unlock (&sbi->writepages); +if (wbc->sync_mode ==WB_SYNC_ALL )atomic_dec (&sbi->wb_sync_req[DATA ]);/* fs/f2fs/f2fs.h +2
-0@@ -913,6 +913,7 @@ struct f2fs_sm_info {unsigned int ipu_policy;/* in-place-update policy */ unsigned int min_ipu_util;/* in-place-update threshold */ unsigned int min_fsync_blocks;/* threshold for fsync */ +unsigned int min_seq_blocks;/* threshold for sequential blocks */ unsigned int min_hot_blocks;/* threshold for hot block allocation */ unsigned int min_ssr_sections;/* threshold to trigger SSR allocation */ @@ -1133,6 +1134,7 @@ struct f2fs_sb_info {struct rw_semaphore sb_lock;/* lock for raw super block */ int valid_super_block;/* valid super block no */ unsigned long s_flag;/* flags for sbi */ +struct mutex writepages;/* mutex for writepages() */ #ifdef CONFIG_BLK_DEV_ZONED unsigned int blocks_per_blkz;/* F2FS blocks per zone */ fs/f2fs/segment.c +1
-0@@ -4131,6 +4131,7 @@ int f2fs_build_segment_manager(struct f2fs_sb_info *sbi) sm_info->ipu_policy =1 <<F2FS_IPU_FSYNC ; sm_info->min_ipu_util =DEF_MIN_IPU_UTIL ; sm_info->min_fsync_blocks =DEF_MIN_FSYNC_BLOCKS ; + sm_info->min_seq_blocks = sbi->blocks_per_seg * sbi->segs_per_sec; sm_info->min_hot_blocks =DEF_MIN_HOT_BLOCKS ; sm_info->min_ssr_sections =reserved_sections (sbi);fs/f2fs/super.c +1
-0@@ -2842,6 +2842,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)/* init f2fs-specific super block info */ sbi->valid_super_block = valid_super_block;mutex_init (&sbi->gc_mutex); +mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);fs/f2fs/sysfs.c +1
-0@@ -397,6 +397,7 @@ F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, batched_trim_sections, trim_sections);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, ipu_policy, ipu_policy);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_ipu_util, min_ipu_util);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_fsync_blocks, min_fsync_blocks); +F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_seq_blocks, min_seq_blocks);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_hot_blocks, min_hot_blocks);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_ssr_sections, min_ssr_sections);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ram_thresh, ram_thresh);@@ -449,6 +450,7 @@ static struct attribute *f2fs_attrs[] = {Quoted 8 lines
fs/f2fs/sysfs.c static struct attribute *f2fs_attrs[] = { · line 456
Quoted 8 lines
fs/f2fs/sysfs.c +1
-0ATTR_LIST (ipu_policy),ATTR_LIST (min_ipu_util),ATTR_LIST (min_fsync_blocks), +ATTR_LIST (min_seq_blocks),ATTR_LIST (min_hot_blocks),ATTR_LIST (min_ssr_sections), ATTR_LIST(max_victim_search),.
.
.
Quoted 92 lines · Jaegeuk Kim
Quoted 91 lines · Chao Yu
Quoted 90 lines · Jaegeuk Kim
Quoted 88 lines · Chao Yu
Quoted 79 lines · Jaegeuk Kim
Quoted 55 lines · Chao Yu
Quoted 54 lines · Jaegeuk Kim
Quoted 53 lines · Chao Yu
Quoted 27 lines · Jaegeuk Kim
Quoted 26 lines · Chao Yu
Hi Jaegeuk,
Quoted 11 lines · Jaegeuk Kim
This reverts the commit - "b93f771 - f2fs: remove writepages lock" to fix the drop in sequential read throughput.
Test: ./tiotest -t 32 -d /data/tio_tmp -f 32 -b 524288 -k 1 -k 3 -L
device: UFSBefore -
read throughput: 185 MB/s
total read requests: 85177 (of these ~80000 are 4KB size requests). total write requests: 2546 (of these ~2208 requests are written in 512KB).Quoted 4 lines
After -
read throughput: 758 MB/s
total read requests: 2417 (of these ~2042 are 512KB reads). total write requests: 2701 (of these ~2034 requests are written in 512KB).IMO, it only impact sequential read performance in a large file which may be fragmented during multi-thread writing.
In android environment, mostly, the large file should be cold type, such as apk, mp3, rmvb, jpeg..., so I think we only need to serialize
writepages()for cold data area writer.Quoted 8 lines
Quoted 5 lines
So how about adding a mount option to serialize
writepage()for different type of log, e.g. in android, using serialize=4; by default, using serialize=7HOT_DATA1WARM_DATA2COLD_DATA4Well, I don't think we need to give too many mount options for this fragmented case. How about doing this for the large files only like this?
Thread A write 512 pages Thread B write 8 pages
-
writepages()
-mutex_lock(&sbi->writepages);
-writepage();
...
-writepages()
-writepage()
....
-writepage();
...
-mutex_unlock(&sbi->writepages);Above case will also cause fragmentation since we didn't serialize all concurrent IO with the lock.
Quoted 8 lines
Quoted 4 lines
Quoted 1 line
Do we need to consider such case?
We can simply allow 512 and 8 in the same segment, which would not a big deal, when considering starvation of Thread B.
Yeah, but in reality, there would be more threads competing in same log header, so I worry that the effect of defragmenting will not so good as we expect, anyway, for benchmark, it's enough.
Basically, I think this is not a benchmark issue. :) It just reveals the issue much easily. Let me think about three cases:
1)WB_SYNC_NONE&WB_SYNC_NONE
-> can simply usemutex_lock2)
WB_SYNC_ALL&WB_SYNC_NONE
-> can usemutex_lockonWB_SYNC_ALLhaving >512 blocks, whileWB_SYNC_NONE
will skip writing blocks3)
WB_SYNC_ALL&WB_SYNC_ALL
-> can usemutex_lockonWB_SYNC_ALLhaving >512 blocks, in order to avoid
starvation.Quoted 6 lines
I've been testing the below.
if (!S_ISDIR(inode->i_mode) && (
wbc->sync_mode!=WB_SYNC_ALL||get_dirty_pages(inode) <= SM_I(sbi)->min_seq_blocks)) { mutex_lock(&sbi->writepages); locked = true;Just cover buffered IO? how about covering Direct IO and atomic write as well?
Quoted 8 lines
Quoted 3 lines
Quoted 1 line
I'd expect direct IO does in-place-updates, and not sure whether we need to
For initial writes, they are not IPU.
It's a little bit different. DIO allocates blocks first in the bulk mode, and sumbit bios later. So, it'd be more likely to allocate consecutive blocks by
get_data_block_dio, if user gave a big chunk to write. I'm more concerend about lock contention, and don't think we have to serialize all the block allocation.
IMO, that's a tradeoff between avoid fragmentation and improving concurrency.
For single kind of above demands, we can separate optimizing design with configuration, enable it dynamically, but there is no single best choice to adapt all demands.
Well, the design is okay for me, and could you send out the patch? :)
Thanks,
Quoted 186 lines
Quoted 183 lines
Quoted 4 lines
add another lock contention between buffered or direct IO. Atomic writes would be covered by ->min_seq_blocks.
Okay. :)
Thanks,
Quoted 174 lines
Quoted 171 lines
Thanks,
Quoted 167 lines
}
Thanks,
Quoted 160 lines
Thanks,
Quoted 157 lines
Quoted 146 lines
Thanks,
Quoted 142 lines
Quoted 2 lines
From
4fea0b6e4da8512a72dd52afc7a51beb35966ad9Mon Sep 17 00:00:00 2001From: Jaegeuk Kim <[email protected]>
Date: Thu, 9 Aug 2018 17:53:34 -0700
Subject: [PATCH] f2fs: fix performance issue observed with multi-thread
sequential readThis reverts the commit - "b93f771 - f2fs: remove writepages lock" to fix the drop in sequential read throughput.
Test: ./tiotest -t 32 -d /data/tio_tmp -f 32 -b 524288 -k 1 -k 3 -L
device: UFSBefore -
read throughput: 185 MB/s
total read requests: 85177 (of these ~80000 are 4KB size requests). total write requests: 2546 (of these ~2208 requests are written in 512KB).After -
read throughput: 758 MB/s
total read requests: 2417 (of these ~2042 are 512KB reads). total write requests: 2701 (of these ~2034 requests are written in 512KB).Signed-off-by Sahitya Tummala <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>--- Documentation/ABI/testing/sysfs-fs-f2fs | 8 ++++++++ fs/f2fs/data.c | 10 ++++++++++ fs/f2fs/f2fs.h | 2 ++ fs/f2fs/segment.c | 1 + fs/f2fs/super.c | 1 + fs/f2fs/sysfs.c | 2 ++ 6 files changed, 24 insertions(+)Documentation/ABI/testing/sysfs-fs-f2fs +8
-0@@ -51,6 +51,14 @@ Description: Controls the dirty page count condition for the in-place-update policies. +What: /sys/fs/f2fs/<disk>/min_seq_blocks +Date: August 2018 +Contact: "Jaegeuk Kim" <[email protected]> +Description: + Controls the dirty page count condition for batched sequential + writes in ->writepages. + + What: /sys/fs/f2fs/<disk>/min_hot_blocks Date: March 2017 Contact: "Jaegeuk Kim" <[email protected]>fs/f2fs/data.c +10
-0@@ -2132,6 +2132,7 @@ static int __f2fs_write_data_pages(struct address_space *mapping,struct f2fs_sb_info *sbi =F2FS_I_SB (inode);struct blk_plug plug;int ret; +bool locked = false;/* deal with chardevs and other special file */ if (!mapping->a_ops->writepage)@@ -2162,10 +2163,19 @@ static int __f2fs_write_data_pages(struct address_space *mapping,else if (atomic_read (&sbi->wb_sync_req[DATA ])) goto skip_write; +if (!S_ISDIR (inode->i_mode) && +get_dirty_pages (inode) <=SM_I (sbi)->min_seq_blocks) { +mutex_lock (&sbi->writepages); + locked = true; + } +blk_start_plug (&plug); ret =f2fs_write_cache_pages (mapping, wbc, io_type);blk_finish_plug (&plug); +if (locked) +mutex_unlock (&sbi->writepages); +if (wbc->sync_mode ==WB_SYNC_ALL )atomic_dec (&sbi->wb_sync_req[DATA ]);/* fs/f2fs/f2fs.h +2
-0@@ -913,6 +913,7 @@ struct f2fs_sm_info {unsigned int ipu_policy;/* in-place-update policy */ unsigned int min_ipu_util;/* in-place-update threshold */ unsigned int min_fsync_blocks;/* threshold for fsync */ +unsigned int min_seq_blocks;/* threshold for sequential blocks */ unsigned int min_hot_blocks;/* threshold for hot block allocation */ unsigned int min_ssr_sections;/* threshold to trigger SSR allocation */ @@ -1133,6 +1134,7 @@ struct f2fs_sb_info {struct rw_semaphore sb_lock;/* lock for raw super block */ int valid_super_block;/* valid super block no */ unsigned long s_flag;/* flags for sbi */ +struct mutex writepages;/* mutex for writepages() */ #ifdef CONFIG_BLK_DEV_ZONED unsigned int blocks_per_blkz;/* F2FS blocks per zone */ fs/f2fs/segment.c +1
-0@@ -4131,6 +4131,7 @@ int f2fs_build_segment_manager(struct f2fs_sb_info *sbi) sm_info->ipu_policy =1 <<F2FS_IPU_FSYNC ; sm_info->min_ipu_util =DEF_MIN_IPU_UTIL ; sm_info->min_fsync_blocks =DEF_MIN_FSYNC_BLOCKS ; + sm_info->min_seq_blocks = sbi->blocks_per_seg * sbi->segs_per_sec; sm_info->min_hot_blocks =DEF_MIN_HOT_BLOCKS ; sm_info->min_ssr_sections =reserved_sections (sbi);fs/f2fs/super.c +1
-0@@ -2842,6 +2842,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)/* init f2fs-specific super block info */ sbi->valid_super_block = valid_super_block;mutex_init (&sbi->gc_mutex); +mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);fs/f2fs/sysfs.c +1
-0@@ -397,6 +397,7 @@ F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, batched_trim_sections, trim_sections);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, ipu_policy, ipu_policy);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_ipu_util, min_ipu_util);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_fsync_blocks, min_fsync_blocks); +F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_seq_blocks, min_seq_blocks);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_hot_blocks, min_hot_blocks);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_ssr_sections, min_ssr_sections);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ram_thresh, ram_thresh);@@ -449,6 +450,7 @@ static struct attribute *f2fs_attrs[] = {Quoted 8 lines
fs/f2fs/sysfs.c static struct attribute *f2fs_attrs[] = { · line 456
Quoted 8 lines
fs/f2fs/sysfs.c +1
-0ATTR_LIST (ipu_policy),ATTR_LIST (min_ipu_util),ATTR_LIST (min_fsync_blocks), +ATTR_LIST (min_seq_blocks),ATTR_LIST (min_hot_blocks),ATTR_LIST (min_ssr_sections), ATTR_LIST(max_victim_search),.
.
.
.
Jaegeuk Kim
maintainerThis reverts the commit - "b93f771 - f2fs: remove writepages lock" to fix the drop in sequential read throughput.
Test: ./tiotest -t 32 -d /data/tio_tmp -f 32 -b 524288 -k 1 -k 3 -L
device: UFS
Before -
read throughput: 185 MB/s
total read requests: 85177 (of these ~80000 are 4KB size requests). total write requests: 2546 (of these ~2208 requests are written in 512KB).
After -
read throughput: 758 MB/s
total read requests: 2417 (of these ~2042 are 512KB reads). total write requests: 2701 (of these ~2034 requests are written in 512KB).
---
Change log from v3:
- add more conditions to serialize the allocation
Documentation/ABI/testing/sysfs-fs-f2fs | 8 ++++++++ fs/f2fs/data.c | 10 ++++++++++ fs/f2fs/f2fs.h | 2 ++ fs/f2fs/segment.c | 1 + fs/f2fs/super.c | 1 + fs/f2fs/sysfs.c | 2 ++ 6 files changed, 24 insertions(+)
Documentation/ABI/testing/sysfs-fs-f2fs +8 -0
@@ -51,6 +51,14 @@ Description: Controls the dirty page count condition for the in-place-update policies. +What: /sys/fs/f2fs/<disk>/min_seq_blocks +Date: August 2018 +Contact: "Jaegeuk Kim" <[email protected]> +Description: + Controls the dirty page count condition for batched sequential + writes in ->writepages. + + What: /sys/fs/f2fs/<disk>/min_hot_blocks Date: March 2017 Contact: "Jaegeuk Kim" <[email protected]>
fs/f2fs/data.c +10 -0
@@ -2130,6 +2130,7 @@ static int __f2fs_write_data_pages(struct address_space *mapping,struct f2fs_sb_info *sbi =F2FS_I_SB (inode);struct blk_plug plug;int ret; +bool locked = false;/* deal with chardevs and other special file */ if (!mapping->a_ops->writepage)
@@ -2160,10 +2161,19 @@ static int __f2fs_write_data_pages(struct address_space *mapping,else if (atomic_read (&sbi->wb_sync_req[DATA ])) goto skip_write; +if (!S_ISDIR (inode->i_mode) && (wbc->sync_mode !=WB_SYNC_ALL || +get_dirty_pages (inode) <=SM_I (sbi)->min_seq_blocks)) { +mutex_lock (&sbi->writepages); + locked = true; + } +blk_start_plug (&plug); ret =f2fs_write_cache_pages (mapping, wbc, io_type);blk_finish_plug (&plug); +if (locked) +mutex_unlock (&sbi->writepages); +if (wbc->sync_mode ==WB_SYNC_ALL )atomic_dec (&sbi->wb_sync_req[DATA ]);/*
fs/f2fs/f2fs.h +2 -0
@@ -913,6 +913,7 @@ struct f2fs_sm_info {unsigned int ipu_policy;/* in-place-update policy */ unsigned int min_ipu_util;/* in-place-update threshold */ unsigned int min_fsync_blocks;/* threshold for fsync */ +unsigned int min_seq_blocks;/* threshold for sequential blocks */ unsigned int min_hot_blocks;/* threshold for hot block allocation */ unsigned int min_ssr_sections;/* threshold to trigger SSR allocation */
@@ -1133,6 +1134,7 @@ struct f2fs_sb_info {struct rw_semaphore sb_lock;/* lock for raw super block */ int valid_super_block;/* valid super block no */ unsigned long s_flag;/* flags for sbi */ +struct mutex writepages;/* mutex for writepages() */ #ifdef CONFIG_BLK_DEV_ZONED unsigned int blocks_per_blkz;/* F2FS blocks per zone */
fs/f2fs/segment.c +1 -0
@@ -4127,6 +4127,7 @@ int f2fs_build_segment_manager(struct f2fs_sb_info *sbi) sm_info->ipu_policy =1 <<F2FS_IPU_FSYNC ; sm_info->min_ipu_util =DEF_MIN_IPU_UTIL ; sm_info->min_fsync_blocks =DEF_MIN_FSYNC_BLOCKS ; + sm_info->min_seq_blocks = sbi->blocks_per_seg * sbi->segs_per_sec; sm_info->min_hot_blocks =DEF_MIN_HOT_BLOCKS ; sm_info->min_ssr_sections =reserved_sections (sbi);
fs/f2fs/super.c +1 -0
@@ -2864,6 +2864,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)/* init f2fs-specific super block info */ sbi->valid_super_block = valid_super_block;mutex_init (&sbi->gc_mutex); +mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);
fs/f2fs/sysfs.c +2 -0
@@ -397,6 +397,7 @@ F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, batched_trim_sections, trim_sections);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, ipu_policy, ipu_policy);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_ipu_util, min_ipu_util);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_fsync_blocks, min_fsync_blocks); +F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_seq_blocks, min_seq_blocks);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_hot_blocks, min_hot_blocks);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_ssr_sections, min_ssr_sections);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ram_thresh, ram_thresh);
@@ -449,6 +450,7 @@ static struct attribute *f2fs_attrs[] = {ATTR_LIST (ipu_policy),ATTR_LIST (min_ipu_util),ATTR_LIST (min_fsync_blocks), +ATTR_LIST (min_seq_blocks),ATTR_LIST (min_hot_blocks),ATTR_LIST (min_ssr_sections), ATTR_LIST(max_victim_search),
Signature · 1 line
2.17.0.441.gb46fe60e1d-goog
Quoted 63 lines · Jaegeuk Kim
This reverts the commit - "b93f771 - f2fs: remove writepages lock" to fix the drop in sequential read throughput.
Test: ./tiotest -t 32 -d /data/tio_tmp -f 32 -b 524288 -k 1 -k 3 -L
device: UFSBefore -
read throughput: 185 MB/s
total read requests: 85177 (of these ~80000 are 4KB size requests). total write requests: 2546 (of these ~2208 requests are written in 512KB).After -
read throughput: 758 MB/s
total read requests: 2417 (of these ~2042 are 512KB reads). total write requests: 2701 (of these ~2034 requests are written in 512KB).Signed-off-by Sahitya Tummala <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>---
Change log from v3:
- add more conditions to serialize the allocationDocumentation/ABI/testing/sysfs-fs-f2fs | 8 ++++++++ fs/f2fs/data.c | 10 ++++++++++ fs/f2fs/f2fs.h | 2 ++ fs/f2fs/segment.c | 1 + fs/f2fs/super.c | 1 + fs/f2fs/sysfs.c | 2 ++ 6 files changed, 24 insertions(+)Documentation/ABI/testing/sysfs-fs-f2fs +8
-0@@ -51,6 +51,14 @@ Description: Controls the dirty page count condition for the in-place-update policies. +What: /sys/fs/f2fs/<disk>/min_seq_blocks +Date: August 2018 +Contact: "Jaegeuk Kim" <[email protected]> +Description: + Controls the dirty page count condition for batched sequential + writes in ->writepages. + + What: /sys/fs/f2fs/<disk>/min_hot_blocks Date: March 2017 Contact: "Jaegeuk Kim" <[email protected]>fs/f2fs/data.c +1
-0@@ -2130,6 +2130,7 @@ static int __f2fs_write_data_pages(struct address_space *mapping,struct f2fs_sb_info *sbi =F2FS_I_SB (inode);struct blk_plug plug;int ret; +bool locked = false;/* deal with chardevs and other special file */ if (!mapping->a_ops->writepage)
fs/f2fs/data.c static int __f2fs_write_data_pages(struct address_space *mapping, · line 2165
Quoted 5 lines
fs/f2fs/data.c +2
-0@@ -2160,10 +2161,19 @@ static int __f2fs_write_data_pages(struct address_space *mapping,else if (atomic_read (&sbi->wb_sync_req[DATA ])) goto skip_write; +if (!S_ISDIR (inode->i_mode) && (wbc->sync_mode !=WB_SYNC_ALL || +get_dirty_pages (inode) <=SM_I (sbi)->min_seq_blocks)) {
get_dirty_pages(inode) >= SM_I(sbi)->min_seq_blocks
fs/f2fs/data.c static int __f2fs_write_data_pages(struct address_space *mapping, · line 2166
Quoted 1 line
fs/f2fs/data.c +1
-0+mutex_lock (&sbi->writepages);
Still didn't see atomic write being covered by this lock.
How about introducing a macro like __should_serialize_io() for indicating the condition in where we should serialize IOs.
Thanks,
Quoted 78 lines
fs/f2fs/data.c +6
-0+ locked = true; + } +blk_start_plug (&plug); ret =f2fs_write_cache_pages (mapping, wbc, io_type);blk_finish_plug (&plug); +if (locked) +mutex_unlock (&sbi->writepages); +if (wbc->sync_mode ==WB_SYNC_ALL )atomic_dec (&sbi->wb_sync_req[DATA ]);/* fs/f2fs/f2fs.h +2
-0@@ -913,6 +913,7 @@ struct f2fs_sm_info {unsigned int ipu_policy;/* in-place-update policy */ unsigned int min_ipu_util;/* in-place-update threshold */ unsigned int min_fsync_blocks;/* threshold for fsync */ +unsigned int min_seq_blocks;/* threshold for sequential blocks */ unsigned int min_hot_blocks;/* threshold for hot block allocation */ unsigned int min_ssr_sections;/* threshold to trigger SSR allocation */ @@ -1133,6 +1134,7 @@ struct f2fs_sb_info {struct rw_semaphore sb_lock;/* lock for raw super block */ int valid_super_block;/* valid super block no */ unsigned long s_flag;/* flags for sbi */ +struct mutex writepages;/* mutex for writepages() */ #ifdef CONFIG_BLK_DEV_ZONED unsigned int blocks_per_blkz;/* F2FS blocks per zone */ fs/f2fs/segment.c +1
-0@@ -4127,6 +4127,7 @@ int f2fs_build_segment_manager(struct f2fs_sb_info *sbi) sm_info->ipu_policy =1 <<F2FS_IPU_FSYNC ; sm_info->min_ipu_util =DEF_MIN_IPU_UTIL ; sm_info->min_fsync_blocks =DEF_MIN_FSYNC_BLOCKS ; + sm_info->min_seq_blocks = sbi->blocks_per_seg * sbi->segs_per_sec; sm_info->min_hot_blocks =DEF_MIN_HOT_BLOCKS ; sm_info->min_ssr_sections =reserved_sections (sbi);fs/f2fs/super.c +1
-0@@ -2864,6 +2864,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)/* init f2fs-specific super block info */ sbi->valid_super_block = valid_super_block;mutex_init (&sbi->gc_mutex); +mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);fs/f2fs/sysfs.c +2
-0@@ -397,6 +397,7 @@ F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, batched_trim_sections, trim_sections);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, ipu_policy, ipu_policy);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_ipu_util, min_ipu_util);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_fsync_blocks, min_fsync_blocks); +F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_seq_blocks, min_seq_blocks);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_hot_blocks, min_hot_blocks);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_ssr_sections, min_ssr_sections);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ram_thresh, ram_thresh);@@ -449,6 +450,7 @@ static struct attribute *f2fs_attrs[] = {ATTR_LIST (ipu_policy),ATTR_LIST (min_ipu_util),ATTR_LIST (min_fsync_blocks), +ATTR_LIST (min_seq_blocks),ATTR_LIST (min_hot_blocks),ATTR_LIST (min_ssr_sections), ATTR_LIST(max_victim_search),
Jaegeuk Kim
maintainerQuoted 67 lines · Chao Yu
Quoted 66 lines · Jaegeuk Kim
This reverts the commit - "b93f771 - f2fs: remove writepages lock" to fix the drop in sequential read throughput.
Test: ./tiotest -t 32 -d /data/tio_tmp -f 32 -b 524288 -k 1 -k 3 -L
device: UFSBefore -
read throughput: 185 MB/s
total read requests: 85177 (of these ~80000 are 4KB size requests). total write requests: 2546 (of these ~2208 requests are written in 512KB).After -
read throughput: 758 MB/s
total read requests: 2417 (of these ~2042 are 512KB reads). total write requests: 2701 (of these ~2034 requests are written in 512KB).Signed-off-by Sahitya Tummala <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>---
Change log from v3:
- add more conditions to serialize the allocationDocumentation/ABI/testing/sysfs-fs-f2fs | 8 ++++++++ fs/f2fs/data.c | 10 ++++++++++ fs/f2fs/f2fs.h | 2 ++ fs/f2fs/segment.c | 1 + fs/f2fs/super.c | 1 + fs/f2fs/sysfs.c | 2 ++ 6 files changed, 24 insertions(+)Documentation/ABI/testing/sysfs-fs-f2fs +8
-0@@ -51,6 +51,14 @@ Description: Controls the dirty page count condition for the in-place-update policies. +What: /sys/fs/f2fs/<disk>/min_seq_blocks +Date: August 2018 +Contact: "Jaegeuk Kim" <[email protected]> +Description: + Controls the dirty page count condition for batched sequential + writes in ->writepages. + + What: /sys/fs/f2fs/<disk>/min_hot_blocks Date: March 2017 Contact: "Jaegeuk Kim" <[email protected]>fs/f2fs/data.c +1
-0@@ -2130,6 +2130,7 @@ static int __f2fs_write_data_pages(struct address_space *mapping,struct f2fs_sb_info *sbi =F2FS_I_SB (inode);struct blk_plug plug;int ret; +bool locked = false;/* deal with chardevs and other special file */ if (!mapping->a_ops->writepage)@@ -2160,10 +2161,19 @@ static int __f2fs_write_data_pages(struct address_space *mapping,else if (atomic_read (&sbi->wb_sync_req[DATA ])) goto skip_write;
Quoted 4 lines
fs/f2fs/data.c static int __f2fs_write_data_pages(struct address_space *mapping, · line 2165
Quoted 2 lines
fs/f2fs/data.c +2
-0+if (!S_ISDIR (inode->i_mode) && (wbc->sync_mode !=WB_SYNC_ALL || +get_dirty_pages (inode) <=SM_I (sbi)->min_seq_blocks)) {
get_dirty_pages(inode)>= SM_I(sbi)->min_seq_blocks
Oops. :P
Quoted 4 lines
fs/f2fs/data.c static int __f2fs_write_data_pages(struct address_space *mapping, · line 2166
Quoted 2 lines
fs/f2fs/data.c +1
-0+mutex_lock (&sbi->writepages);Still didn't see atomic write being covered by this lock.
Taking a look at this again, I'm in doubt to cover this, since 1) normal usecase of atomic writes is to set page dirty and write it right away during commit, 2) there'd be no large number of dirty pages even when we consider race condition between writepages and atomic_commit. Am I missing another case?
Quoted 3 lines
How about introducing a macro like
__should_serialize_io()for indicating the condition in where we should serialize IOs.
Done.
Thank you for ths suggestion.
Quoted 81 lines
Thanks,
Quoted 78 lines
fs/f2fs/data.c +6
-0+ locked = true; + } +blk_start_plug (&plug); ret =f2fs_write_cache_pages (mapping, wbc, io_type);blk_finish_plug (&plug); +if (locked) +mutex_unlock (&sbi->writepages); +if (wbc->sync_mode ==WB_SYNC_ALL )atomic_dec (&sbi->wb_sync_req[DATA ]);/* fs/f2fs/f2fs.h +2
-0@@ -913,6 +913,7 @@ struct f2fs_sm_info {unsigned int ipu_policy;/* in-place-update policy */ unsigned int min_ipu_util;/* in-place-update threshold */ unsigned int min_fsync_blocks;/* threshold for fsync */ +unsigned int min_seq_blocks;/* threshold for sequential blocks */ unsigned int min_hot_blocks;/* threshold for hot block allocation */ unsigned int min_ssr_sections;/* threshold to trigger SSR allocation */ @@ -1133,6 +1134,7 @@ struct f2fs_sb_info {struct rw_semaphore sb_lock;/* lock for raw super block */ int valid_super_block;/* valid super block no */ unsigned long s_flag;/* flags for sbi */ +struct mutex writepages;/* mutex for writepages() */ #ifdef CONFIG_BLK_DEV_ZONED unsigned int blocks_per_blkz;/* F2FS blocks per zone */ fs/f2fs/segment.c +1
-0@@ -4127,6 +4127,7 @@ int f2fs_build_segment_manager(struct f2fs_sb_info *sbi) sm_info->ipu_policy =1 <<F2FS_IPU_FSYNC ; sm_info->min_ipu_util =DEF_MIN_IPU_UTIL ; sm_info->min_fsync_blocks =DEF_MIN_FSYNC_BLOCKS ; + sm_info->min_seq_blocks = sbi->blocks_per_seg * sbi->segs_per_sec; sm_info->min_hot_blocks =DEF_MIN_HOT_BLOCKS ; sm_info->min_ssr_sections =reserved_sections (sbi);fs/f2fs/super.c +1
-0@@ -2864,6 +2864,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)/* init f2fs-specific super block info */ sbi->valid_super_block = valid_super_block;mutex_init (&sbi->gc_mutex); +mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);fs/f2fs/sysfs.c +2
-0@@ -397,6 +397,7 @@ F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, batched_trim_sections, trim_sections);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, ipu_policy, ipu_policy);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_ipu_util, min_ipu_util);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_fsync_blocks, min_fsync_blocks); +F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_seq_blocks, min_seq_blocks);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_hot_blocks, min_hot_blocks);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_ssr_sections, min_ssr_sections);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ram_thresh, ram_thresh);@@ -449,6 +450,7 @@ static struct attribute *f2fs_attrs[] = {ATTR_LIST (ipu_policy),ATTR_LIST (min_ipu_util),ATTR_LIST (min_fsync_blocks), +ATTR_LIST (min_seq_blocks),ATTR_LIST (min_hot_blocks),ATTR_LIST (min_ssr_sections), ATTR_LIST(max_victim_search),
Quoted 76 lines · Jaegeuk Kim
Quoted 67 lines · Chao Yu
Quoted 66 lines · Jaegeuk Kim
This reverts the commit - "b93f771 - f2fs: remove writepages lock" to fix the drop in sequential read throughput.
Test: ./tiotest -t 32 -d /data/tio_tmp -f 32 -b 524288 -k 1 -k 3 -L
device: UFSBefore -
read throughput: 185 MB/s
total read requests: 85177 (of these ~80000 are 4KB size requests). total write requests: 2546 (of these ~2208 requests are written in 512KB).After -
read throughput: 758 MB/s
total read requests: 2417 (of these ~2042 are 512KB reads). total write requests: 2701 (of these ~2034 requests are written in 512KB).Signed-off-by Sahitya Tummala <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>---
Change log from v3:
- add more conditions to serialize the allocationDocumentation/ABI/testing/sysfs-fs-f2fs | 8 ++++++++ fs/f2fs/data.c | 10 ++++++++++ fs/f2fs/f2fs.h | 2 ++ fs/f2fs/segment.c | 1 + fs/f2fs/super.c | 1 + fs/f2fs/sysfs.c | 2 ++ 6 files changed, 24 insertions(+)Documentation/ABI/testing/sysfs-fs-f2fs +8
-0@@ -51,6 +51,14 @@ Description: Controls the dirty page count condition for the in-place-update policies. +What: /sys/fs/f2fs/<disk>/min_seq_blocks +Date: August 2018 +Contact: "Jaegeuk Kim" <[email protected]> +Description: + Controls the dirty page count condition for batched sequential + writes in ->writepages. + + What: /sys/fs/f2fs/<disk>/min_hot_blocks Date: March 2017 Contact: "Jaegeuk Kim" <[email protected]>fs/f2fs/data.c +1
-0@@ -2130,6 +2130,7 @@ static int __f2fs_write_data_pages(struct address_space *mapping,struct f2fs_sb_info *sbi =F2FS_I_SB (inode);struct blk_plug plug;int ret; +bool locked = false;/* deal with chardevs and other special file */ if (!mapping->a_ops->writepage)@@ -2160,10 +2161,19 @@ static int __f2fs_write_data_pages(struct address_space *mapping,else if (atomic_read (&sbi->wb_sync_req[DATA ])) goto skip_write;Quoted 4 lines
fs/f2fs/data.c static int __f2fs_write_data_pages(struct address_space *mapping, · line 2165
Quoted 2 lines
fs/f2fs/data.c +2
-0+if (!S_ISDIR (inode->i_mode) && (wbc->sync_mode !=WB_SYNC_ALL || +get_dirty_pages (inode) <=SM_I (sbi)->min_seq_blocks)) {
get_dirty_pages(inode)>= SM_I(sbi)->min_seq_blocksOops. :P
Quoted 1 line
Quoted 8 lines
Quoted 3 lines
fs/f2fs/data.c static int __f2fs_write_data_pages(struct address_space *mapping, · line 2166
Quoted 1 line
fs/f2fs/data.c +1
-0+mutex_lock (&sbi->writepages);Still didn't see atomic write being covered by this lock.
Taking a look at this again, I'm in doubt to cover this, since 1) normal usecase of atomic writes is to set page dirty and write it right away during commit, 2) there'd be no large number of dirty pages even when we consider race condition between writepages and
atomic_commit. Am I missing another case?
Yup, reasonable, hot type data is not fit for this optimization, due to easily defragmenting, and small size. :)
Thanks,
Quoted 93 lines
Quoted 4 lines
How about introducing a macro like
__should_serialize_io()for indicating the condition in where we should serialize IOs.Done.
Thank you for ths suggestion.
Quoted 73 lines
Thanks,
Quoted 70 lines
fs/f2fs/data.c +6
-0+ locked = true; + } +blk_start_plug (&plug); ret =f2fs_write_cache_pages (mapping, wbc, io_type);blk_finish_plug (&plug); +if (locked) +mutex_unlock (&sbi->writepages); +if (wbc->sync_mode ==WB_SYNC_ALL )atomic_dec (&sbi->wb_sync_req[DATA ]);/* fs/f2fs/f2fs.h +2
-0@@ -913,6 +913,7 @@ struct f2fs_sm_info {unsigned int ipu_policy;/* in-place-update policy */ unsigned int min_ipu_util;/* in-place-update threshold */ unsigned int min_fsync_blocks;/* threshold for fsync */ +unsigned int min_seq_blocks;/* threshold for sequential blocks */ unsigned int min_hot_blocks;/* threshold for hot block allocation */ unsigned int min_ssr_sections;/* threshold to trigger SSR allocation */ @@ -1133,6 +1134,7 @@ struct f2fs_sb_info {struct rw_semaphore sb_lock;/* lock for raw super block */ int valid_super_block;/* valid super block no */ unsigned long s_flag;/* flags for sbi */ +struct mutex writepages;/* mutex for writepages() */ #ifdef CONFIG_BLK_DEV_ZONED unsigned int blocks_per_blkz;/* F2FS blocks per zone */ fs/f2fs/segment.c +1
-0@@ -4127,6 +4127,7 @@ int f2fs_build_segment_manager(struct f2fs_sb_info *sbi) sm_info->ipu_policy =1 <<F2FS_IPU_FSYNC ; sm_info->min_ipu_util =DEF_MIN_IPU_UTIL ; sm_info->min_fsync_blocks =DEF_MIN_FSYNC_BLOCKS ; + sm_info->min_seq_blocks = sbi->blocks_per_seg * sbi->segs_per_sec; sm_info->min_hot_blocks =DEF_MIN_HOT_BLOCKS ; sm_info->min_ssr_sections =reserved_sections (sbi);fs/f2fs/super.c +1
-0@@ -2864,6 +2864,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)/* init f2fs-specific super block info */ sbi->valid_super_block = valid_super_block;mutex_init (&sbi->gc_mutex); +mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);fs/f2fs/sysfs.c +1
-0@@ -397,6 +397,7 @@ F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, batched_trim_sections, trim_sections);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, ipu_policy, ipu_policy);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_ipu_util, min_ipu_util);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_fsync_blocks, min_fsync_blocks); +F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_seq_blocks, min_seq_blocks);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_hot_blocks, min_hot_blocks);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_ssr_sections, min_ssr_sections);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ram_thresh, ram_thresh);@@ -449,6 +450,7 @@ static struct attribute *f2fs_attrs[] = {Quoted 8 lines
fs/f2fs/sysfs.c static struct attribute *f2fs_attrs[] = { · line 456
Quoted 8 lines
fs/f2fs/sysfs.c +1
-0ATTR_LIST (ipu_policy),ATTR_LIST (min_ipu_util),ATTR_LIST (min_fsync_blocks), +ATTR_LIST (min_seq_blocks),ATTR_LIST (min_hot_blocks),ATTR_LIST (min_ssr_sections), ATTR_LIST(max_victim_search),.
Jaegeuk Kim
maintainerThis reverts the commit - "b93f771 - f2fs: remove writepages lock" to fix the drop in sequential read throughput.
Test: ./tiotest -t 32 -d /data/tio_tmp -f 32 -b 524288 -k 1 -k 3 -L
device: UFS
Before -
read throughput: 185 MB/s
total read requests: 85177 (of these ~80000 are 4KB size requests). total write requests: 2546 (of these ~2208 requests are written in 512KB).
After -
read throughput: 758 MB/s
total read requests: 2417 (of these ~2042 are 512KB reads). total write requests: 2701 (of these ~2034 requests are written in 512KB).
---
Change log from v4:
- add __should_serialize_io
- fix wrong condition
Documentation/ABI/testing/sysfs-fs-f2fs | 8 ++++++++ fs/f2fs/data.c | 21 +++++++++++++++++++++ fs/f2fs/f2fs.h | 2 ++ fs/f2fs/segment.c | 1 + fs/f2fs/super.c | 1 + fs/f2fs/sysfs.c | 2 ++ 6 files changed, 35 insertions(+)
Documentation/ABI/testing/sysfs-fs-f2fs +8 -0
@@ -51,6 +51,14 @@ Description: Controls the dirty page count condition for the in-place-update policies. +What: /sys/fs/f2fs/<disk>/min_seq_blocks +Date: August 2018 +Contact: "Jaegeuk Kim" <[email protected]> +Description: + Controls the dirty page count condition for batched sequential + writes in ->writepages. + + What: /sys/fs/f2fs/<disk>/min_hot_blocks Date: March 2017 Contact: "Jaegeuk Kim" <[email protected]>
fs/f2fs/data.c +21 -0
@@ -2122,6 +2122,18 @@ static int f2fs_write_cache_pages(struct address_space *mapping,return ret; } +static inline bool __should_serialize_io (struct inode *inode, +struct writeback_control *wbc) +{ +if (!S_ISREG (inode->i_mode)) +return false; +if (wbc->sync_mode !=WB_SYNC_ALL ) +return true; +if (get_dirty_pages (inode) >=SM_I (F2FS_I_SB (inode))->min_seq_blocks) +return true; +return false; +} +static int __f2fs_write_data_pages (struct address_space *mapping,struct writeback_control *wbc,enum iostat_type io_type)
@@ -2130,6 +2142,7 @@ static int __f2fs_write_data_pages(struct address_space *mapping,struct f2fs_sb_info *sbi =F2FS_I_SB (inode);struct blk_plug plug;int ret; +bool locked = false;/* deal with chardevs and other special file */ if (!mapping->a_ops->writepage)
@@ -2160,10 +2173,18 @@ static int __f2fs_write_data_pages(struct address_space *mapping,else if (atomic_read (&sbi->wb_sync_req[DATA ])) goto skip_write; +if (__should_serialize_io (inode, wbc)) { +mutex_lock (&sbi->writepages); + locked = true; + } +blk_start_plug (&plug); ret =f2fs_write_cache_pages (mapping, wbc, io_type);blk_finish_plug (&plug); +if (locked) +mutex_unlock (&sbi->writepages); +if (wbc->sync_mode ==WB_SYNC_ALL )atomic_dec (&sbi->wb_sync_req[DATA ]);/*
fs/f2fs/f2fs.h +2 -0
@@ -913,6 +913,7 @@ struct f2fs_sm_info {unsigned int ipu_policy;/* in-place-update policy */ unsigned int min_ipu_util;/* in-place-update threshold */ unsigned int min_fsync_blocks;/* threshold for fsync */ +unsigned int min_seq_blocks;/* threshold for sequential blocks */ unsigned int min_hot_blocks;/* threshold for hot block allocation */ unsigned int min_ssr_sections;/* threshold to trigger SSR allocation */
@@ -1133,6 +1134,7 @@ struct f2fs_sb_info {struct rw_semaphore sb_lock;/* lock for raw super block */ int valid_super_block;/* valid super block no */ unsigned long s_flag;/* flags for sbi */ +struct mutex writepages;/* mutex for writepages() */ #ifdef CONFIG_BLK_DEV_ZONED unsigned int blocks_per_blkz;/* F2FS blocks per zone */
fs/f2fs/segment.c +1 -0
@@ -4127,6 +4127,7 @@ int f2fs_build_segment_manager(struct f2fs_sb_info *sbi) sm_info->ipu_policy =1 <<F2FS_IPU_FSYNC ; sm_info->min_ipu_util =DEF_MIN_IPU_UTIL ; sm_info->min_fsync_blocks =DEF_MIN_FSYNC_BLOCKS ; + sm_info->min_seq_blocks = sbi->blocks_per_seg * sbi->segs_per_sec; sm_info->min_hot_blocks =DEF_MIN_HOT_BLOCKS ; sm_info->min_ssr_sections =reserved_sections (sbi);
fs/f2fs/super.c +1 -0
@@ -2842,6 +2842,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)/* init f2fs-specific super block info */ sbi->valid_super_block = valid_super_block;mutex_init (&sbi->gc_mutex); +mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);
fs/f2fs/sysfs.c +2 -0
@@ -397,6 +397,7 @@ F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, batched_trim_sections, trim_sections);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, ipu_policy, ipu_policy);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_ipu_util, min_ipu_util);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_fsync_blocks, min_fsync_blocks); +F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_seq_blocks, min_seq_blocks);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_hot_blocks, min_hot_blocks);F2FS_RW_ATTR (SM_INFO , f2fs_sm_info, min_ssr_sections, min_ssr_sections);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ram_thresh, ram_thresh);
@@ -449,6 +450,7 @@ static struct attribute *f2fs_attrs[] = {ATTR_LIST (ipu_policy),ATTR_LIST (min_ipu_util),ATTR_LIST (min_fsync_blocks), +ATTR_LIST (min_seq_blocks),ATTR_LIST (min_hot_blocks),ATTR_LIST (min_ssr_sections), ATTR_LIST(max_victim_search),
Signature · 1 line
2.17.0.441.gb46fe60e1d-goog
Chao Yu
Reviewed-byQuoted 55 lines · Jaegeuk Kim
This reverts the commit - "b93f771 - f2fs: remove writepages lock" to fix the drop in sequential read throughput.
Test: ./tiotest -t 32 -d /data/tio_tmp -f 32 -b 524288 -k 1 -k 3 -L
device: UFSBefore -
read throughput: 185 MB/s
total read requests: 85177 (of these ~80000 are 4KB size requests). total write requests: 2546 (of these ~2208 requests are written in 512KB).After -
read throughput: 758 MB/s
total read requests: 2417 (of these ~2042 are 512KB reads). total write requests: 2701 (of these ~2034 requests are written in 512KB).Signed-off-by Sahitya Tummala <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>---
Change log from v4:
- add__should_serialize_io
- fix wrong conditionDocumentation/ABI/testing/sysfs-fs-f2fs | 8 ++++++++ fs/f2fs/data.c | 21 +++++++++++++++++++++ fs/f2fs/f2fs.h | 2 ++ fs/f2fs/segment.c | 1 + fs/f2fs/super.c | 1 + fs/f2fs/sysfs.c | 2 ++ 6 files changed, 35 insertions(+)Documentation/ABI/testing/sysfs-fs-f2fs +8
-0@@ -51,6 +51,14 @@ Description: Controls the dirty page count condition for the in-place-update policies. +What: /sys/fs/f2fs/<disk>/min_seq_blocks +Date: August 2018 +Contact: "Jaegeuk Kim" <[email protected]> +Description: + Controls the dirty page count condition for batched sequential + writes in ->writepages. + + What: /sys/fs/f2fs/<disk>/min_hot_blocks Date: March 2017 Contact: "Jaegeuk Kim" <[email protected]>fs/f2fs/data.c +0
-0
fs/f2fs/data.c static int f2fs_write_cache_pages(struct address_space *mapping, · line 2128
Quoted 7 lines
fs/f2fs/data.c +4
-0@@ -2122,6 +2122,18 @@ static int f2fs_write_cache_pages(struct address_space *mapping,return ret; } +static inline bool __should_serialize_io (struct inode *inode, +struct writeback_control *wbc) +{ +if (!S_ISREG (inode->i_mode))
Good catch! Will be better. :)
Thanks,