btrfs llseek improvement, take 2
v2 cover btrfs llseek improvement, take 2
Here is v2 of the llseek improvements, main changes are:
* Patch 1 - changed the locking scheme. I'm now using inode_lock_shared since holding the extent lock is not sufficient to prevent concurrent truncates.
* Fixed lingo bugs in patch 2 changelog (Johaness)
Nikolay Borisov (3):
btrfs: Speed up btrfs_file_llseek
btrfs: Simplify btrfs_file_llseek
btrfs: Return offset from find_desired_extent
fs/btrfs/file.c | 62 ++++++++++++++++++++++--------------------------- 1 file changed, 28 insertions(+), 34 deletions(-)
Signature · 1 line
2.17.1
PATCH v2 1/3 btrfs: Speed up btrfs_file_llseek
Modifying the file position is done on a per-file basis. This renders holding the inode lock for writing useless and makes the performance of concurrent llseek's abysmal.
Fix this by holding the inode for read. This provides protection against concurrent truncates and find_desired_extent already includes proper extent locking for the range which ensures proper locking against concurrent writes. SEEK_CUR and SEEK_END can be done lockessly. The former is synchronized by file::f_lock spinlock. SEEK_END is not synchronized but atomic, but that's OK since there is not guarantee that SEEK_END will always be at the end of the file in the face of tail modifications.
This change brings ~82% performance improvement when doing a lot of parallel fseeks. The workload essentially does:
for (d=0; d<num_seek_read; d++)
{
/* offset %= 16777216; */
fseek (f, 256 * d % 16777216, SEEK_SET);
fread (buffer, 64, 1, f);
}Without patch:
num workprocesses = 16
num fseek/fread = 8000000
step = 256
fork 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
real 0m41.412s
user 0m28.777s
sys 2m16.510s
With patch:
num workprocesses = 16
num fseek/fread = 8000000
step = 256
fork 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
real 0m11.479s
user 0m27.629s
sys 0m21.040s
--- fs/btrfs/file.c | 26 ++++++++++---------------- 1 file changed, 10 insertions(+), 16 deletions(-)
fs/btrfs/file.c +10 -16
@@ -3347,13 +3347,14 @@ static int find_desired_extent(struct inode *inode, loff_t *offset, int whence)struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb);struct extent_map *em =NULL ;struct extent_state *cached_state =NULL ; +loff_t i_size = inode->i_size;u64 lockstart;u64 lockend;u64 start;u64 len;int ret =0 ; -if (inode->i_size ==0 ) +if (i_size ==0 || *offset >= i_size)return -ENXIO ;/*
@@ -3363,8 +3364,7 @@ static int find_desired_extent(struct inode *inode, loff_t *offset, int whence) start =max_t (loff_t,0 , *offset); lockstart =round_down (start, fs_info->sectorsize); - lockend =round_up (i_size_read (inode), - fs_info->sectorsize); + lockend =round_up (i_size, fs_info->sectorsize);if (lockend <= lockstart) lockend = lockstart + fs_info->sectorsize; lockend--;
@@ -3373,7 +3373,7 @@ static int find_desired_extent(struct inode *inode, loff_t *offset, int whence)lock_extent_bits (&BTRFS_I (inode)->io_tree, lockstart, lockend, &cached_state); -while (start < inode->i_size) { +while (start < i_size) { em =btrfs_get_extent_fiemap (BTRFS_I (inode), start, len);if (IS_ERR (em)) { ret =PTR_ERR (em);
@@ -3397,10 +3397,10 @@ static int find_desired_extent(struct inode *inode, loff_t *offset, int whence) }free_extent_map (em);if (!ret) { -if (whence ==SEEK_DATA && start >= inode->i_size) +if (whence ==SEEK_DATA && start >= i_size) ret = -ENXIO ;else - *offset =min_t (loff_t, start, inode->i_size); + *offset =min_t (loff_t, start, i_size); }unlock_extent_cached (&BTRFS_I (inode)->io_tree, lockstart, lockend, &cached_state);
@@ -3412,7 +3412,6 @@ static loff_t btrfs_file_llseek(struct file *file, loff_t offset, int whence)struct inode *inode = file->f_mapping->host;int ret; -inode_lock (inode);switch (whence) {case SEEK_END :case SEEK_CUR :
@@ -3420,21 +3419,16 @@ static loff_t btrfs_file_llseek(struct file *file, loff_t offset, int whence) goto out;case SEEK_DATA :case SEEK_HOLE : -if (offset >=i_size_read (inode)) { -inode_unlock (inode); -return -ENXIO ; - } - +inode_lock_shared (inode); ret =find_desired_extent (inode, &offset, whence); -if (ret) { -inode_unlock (inode); +inode_unlock_shared (inode); + +if (ret)return ret; - } } offset =vfs_setpos (file, offset, inode->i_sb->s_maxbytes); out: -inode_unlock (inode);return offset; }
Signature · 1 line
2.17.1
Re: [PATCH v2 1/3] btrfs: Speed up btrfs_file_llseek
Quoted 55 lines · Nikolay Borisov
Modifying the file position is done on a per-file basis. This renders holding the inode lock for writing useless and makes the performance of concurrent llseek's abysmal.
Fix this by holding the inode for read. This provides protection against concurrent truncates and
find_desired_extentalready includes proper extent locking for the range which ensures proper locking against concurrent writes.SEEK_CURandSEEK_ENDcan be done lockessly. The former is synchronized byfile::f_lockspinlock.SEEK_ENDis not synchronized but atomic, but that's OK since there is not guarantee thatSEEK_ENDwill always be at the end of the file in the face of tail modifications.This change brings ~82% performance improvement when doing a lot of parallel fseeks. The workload essentially does:
for (d=0; d<num_seek_read; d++) { /* offset %= 16777216; */ fseek (f, 256 * d % 16777216, SEEK_SET); fread (buffer, 64, 1, f); }Without patch:
num workprocesses = 16
num fseek/fread = 8000000
step = 256
fork 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15real 0m41.412s
user 0m28.777s
sys 2m16.510sWith patch:
num workprocesses = 16
num fseek/fread = 8000000
step = 256
fork 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15real 0m11.479s
user 0m27.629s
sys 0m21.040sSigned-off-by Nikolay Borisov <[email protected]>--- fs/btrfs/file.c | 26 ++++++++++---------------- 1 file changed, 10 insertions(+), 16 deletions(-)fs/btrfs/file.c +0
-0
fs/btrfs/file.c static int find_desired_extent(struct inode *inode, loff_t *offset, int whence) · line 3350
Quoted 4 lines
fs/btrfs/file.c +1
-0@@ -3347,13 +3347,14 @@ static int find_desired_extent(struct inode *inode, loff_t *offset, int whence)struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb);struct extent_map *em =NULL ;struct extent_state *cached_state =NULL ; +loff_t i_size = inode->i_size;
We don't actually need to do all this now that we're holding the inode_lock right? Also I've gone through and looked at stuff and we're good with just a shared lock here, the only thing that adjusts i_size outsize of the extent lock is truncate, so we're safe. Thanks,
Josef
Re: [PATCH v2 1/3] btrfs: Speed up btrfs_file_llseek
Quoted 51 lines · Josef Bacik
Quoted 50 lines · Nikolay Borisov
Modifying the file position is done on a per-file basis. This renders holding the inode lock for writing useless and makes the performance of concurrent llseek's abysmal.
Fix this by holding the inode for read. This provides protection against concurrent truncates and
find_desired_extentalready includes proper extent locking for the range which ensures proper locking against concurrent writes.SEEK_CURandSEEK_ENDcan be done lockessly. The former is synchronized byfile::f_lockspinlock.SEEK_ENDis not synchronized but atomic, but that's OK since there is not guarantee thatSEEK_ENDwill always be at the end of the file in the face of tail modifications.This change brings ~82% performance improvement when doing a lot of parallel fseeks. The workload essentially does:
for (d=0; d<num_seek_read; d++) { /* offset %= 16777216; */ fseek (f, 256 * d % 16777216, SEEK_SET); fread (buffer, 64, 1, f); }Without patch:
num workprocesses = 16
num fseek/fread = 8000000
step = 256
fork 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15real 0m41.412s
user 0m28.777s
sys 2m16.510sWith patch:
num workprocesses = 16
num fseek/fread = 8000000
step = 256
fork 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15real 0m11.479s
user 0m27.629s
sys 0m21.040sSigned-off-by Nikolay Borisov <[email protected]>--- fs/btrfs/file.c | 26 ++++++++++---------------- 1 file changed, 10 insertions(+), 16 deletions(-)
Quoted 14 lines
fs/btrfs/file.c static int find_desired_extent(struct inode *inode, loff_t *offset, int whence) · line 3350
Quoted 9 lines
fs/btrfs/file.c +1
-0@@ -3347,13 +3347,14 @@ static int find_desired_extent(struct inode *inode, loff_t *offset, int whence)struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb);struct extent_map *em =NULL ;struct extent_state *cached_state =NULL ; +loff_t i_size = inode->i_size;We don't actually need to do all this now that we're holding the
inode_lockright? Also I've gone through and looked at stuff and we're good with just a shared lock here, the only thing that adjustsi_sizeoutsize of the extent lock is truncate, so we're safe. Thanks,
Yeah, holding the shared inode lock means we can just do inode->i_size but dunno if the multiple dereferences gets optimised. Though at this point we are entering into microoptimisation territory. For the sake of completeness I will check on monday what's the difference in assembly and if there is none I'll revert the code back to accessing inode->i_size.
Quoted 3 lines
Josef
PATCH v2 2/3 btrfs: Simplify btrfs_file_llseek
In reply to Nikolay BorisovHandle SEEK_END/SEEK_CUR in a single 'default' case by directly returning from generic_file_llseek. This makes the 'out' label redundant. Finally return directly the vale from vfs_setpos. No semantic changes.
--- fs/btrfs/file.c | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-)
fs/btrfs/file.c +3 -7
@@ -3413,10 +3413,8 @@ static loff_t btrfs_file_llseek(struct file *file, loff_t offset, int whence)int ret;switch (whence) { -case SEEK_END : -case SEEK_CUR : - offset =generic_file_llseek (file, offset, whence); - goto out; +default : +return generic_file_llseek (file, offset, whence);case SEEK_DATA :case SEEK_HOLE :inode_lock_shared (inode);
@@ -3427,9 +3425,7 @@ static loff_t btrfs_file_llseek(struct file *file, loff_t offset, int whence)return ret; } - offset =vfs_setpos (file, offset, inode->i_sb->s_maxbytes); -out: -return offset; +return vfs_setpos (file, offset, inode->i_sb->s_maxbytes); }static int btrfs_file_open (struct inode *inode,struct file *filp)
Signature · 1 line
2.17.1
Re: [PATCH v2 2/3] btrfs: Simplify btrfs_file_llseek
I thought I already did that for v1, but:
Signature · 8 lines
Johannes Thumshirn SUSE Labs Filesystems [email protected] +49 911 74053 689 SUSE Software Solutions Germany GmbH Maxfeldstr. 5 90409 Nürnberg Germany (HRB 247165, AG München) Key fingerprint = EC38 9CAB C2C4 F25D 8600 D0D0 0393 969D 2D76 0850
PATCH v2 3/3 btrfs: Return offset from find_desired_extent
In reply to Nikolay BorisovInstead of using an input pointer parameter as the return value and have an int as the return type of find_desired_extent, rework the function to directly return the found offset. Doing that the 'ret' variable in btrfs_llseek_file can be removed. Additional (subjective) benefit is that btrfs' llseek function now resemebles those of the other major filesystems.
--- fs/btrfs/file.c | 34 +++++++++++++++++++--------------- 1 file changed, 19 insertions(+), 15 deletions(-)
fs/btrfs/file.c +19 -15
@@ -3342,7 +3342,8 @@ static long btrfs_fallocate(struct file *file, int mode,return ret; } -static int find_desired_extent (struct inode *inode,loff_t *offset,int whence) +static loff_t find_desired_extent (struct inode *inode,loff_t offset, +int whence) {struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb);struct extent_map *em =NULL ;
@@ -3354,14 +3355,14 @@ static int find_desired_extent(struct inode *inode, loff_t *offset, int whence)u64 len;int ret =0 ; -if (i_size ==0 || *offset >= i_size) +if (i_size ==0 || offset >= i_size)return -ENXIO ;/* -* *offset can be negative, in this case we start finding DATA/HOLE from +* offset can be negative, in this case we start finding DATA/HOLE from * the very start of the file. */ - start =max_t (loff_t,0 , *offset); + start =max_t (loff_t,0 , offset); lockstart =round_down (start, fs_info->sectorsize); lockend =round_up (i_size, fs_info->sectorsize);
@@ -3396,21 +3397,23 @@ static int find_desired_extent(struct inode *inode, loff_t *offset, int whence)cond_resched (); }free_extent_map (em); -if (!ret) { +unlock_extent_cached (&BTRFS_I (inode)->io_tree, lockstart, lockend, + &cached_state); +if (ret) { + offset = ret; + }else {if (whence ==SEEK_DATA && start >= i_size) - ret = -ENXIO ; + offset = -ENXIO ;else - *offset =min_t (loff_t, start, i_size); + offset =min_t (loff_t, start, i_size); } -unlock_extent_cached (&BTRFS_I (inode)->io_tree, lockstart, lockend, - &cached_state); -return ret; + +return offset; }static loff_t btrfs_file_llseek (struct file *file,loff_t offset,int whence) {struct inode *inode = file->f_mapping->host; -int ret;switch (whence) {default :
@@ -3418,13 +3421,14 @@ static loff_t btrfs_file_llseek(struct file *file, loff_t offset, int whence)case SEEK_DATA :case SEEK_HOLE :inode_lock_shared (inode); - ret =find_desired_extent (inode, &offset, whence); + offset =find_desired_extent (inode, offset, whence);inode_unlock_shared (inode); - -if (ret) -return ret; +break ; } +if (offset <0 ) +return offset; +return vfs_setpos (file, offset, inode->i_sb->s_maxbytes); }
Signature · 1 line
2.17.1
Re: [PATCH v2 3/3] btrfs: Return offset from find_desired_extent
Signature · 8 lines
Johannes Thumshirn SUSE Labs Filesystems [email protected] +49 911 74053 689 SUSE Software Solutions Germany GmbH Maxfeldstr. 5 90409 Nürnberg Germany (HRB 247165, AG München) Key fingerprint = EC38 9CAB C2C4 F25D 8600 D0D0 0393 969D 2D76 0850
Quoted 4 lines · Nikolay Borisov
Here is v2 of the llseek improvements, main changes are:
* Patch 1 - changed the locking scheme. I'm now using
inode_lock_sharedsince holding the extent lock is not sufficient to prevent concurrent truncates.
Regarding the offline discussions, I'd like to see more people look at that until we're sure that it works, namely seek vs truncate and extent range locking.
Quoted 1 line · Nikolay Borisov
Here is v2 of the llseek improvements, main changes are:
Btw, with Goldwyn looking into btrfs iomap support wouldn't it make sense to try to reuse the iomap lseek code?
Quoted 4 lines · Christoph Hellwig
Quoted 1 line
Here is v2 of the llseek improvements, main changes are:
Btw, with Goldwyn looking into btrfs iomap support wouldn't it make sense to try to reuse the iomap lseek code?
When that code lands - yes. ATM - there are more pressing stuff.
Quoted 11 lines · Nikolay Borisov
Here is v2 of the llseek improvements, main changes are:
* Patch 1 - changed the locking scheme. I'm now using
inode_lock_sharedsince holding the extent lock is not sufficient to prevent concurrent truncates.* Fixed lingo bugs in patch 2 changelog (Johaness)
Nikolay Borisov (3):
btrfs: Speed upbtrfs_file_llseek
btrfs: Simplifybtrfs_file_llseek
btrfs: Return offset fromfind_desired_extent
Moved from topic branch to misc-next. Thanks.