Skip to contentSkip to conversation

f2fs: enhance multithread dio write performance

PATCH Superseded Chao Yu 3 participants 10 messages Sep 11, 2015 – Dec 11, 2015 F2FS file system

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore

Chao Yu

author
#0 lore raw

PATCH 5/7 f2fs: enhance multithread dio write performance

When dio writes perform concurrently, our performace will be low because of Thread A's allocation of multi continuous blocks will be break by Thread B, there are two cases as below:
- In Thread B, we may change current segment to a new segment for LFS allocation if we dio write in the beginning of the file.
- In Thread B, we may allocate blocks in the middle of Thread A's allocation, which make blocks which allocated in Thread A being discontinuous.

This patch adds writepages mutex lock to make block allocation in dio write atomic to avoid above issues.

Test environment:
ubuntu os with linux kernel 4.2+, intel i7-3770, 16g memory, 32g kingston sd card.

fio --name seqw --ioengine=sync --invalidate=1 --rw=write --directory=/mnt/f2fs --filesize=256m --size=16m --bs=2m --direct=1 --numjobs=10

before:
WRITE: io=163840KB, aggrb=3145KB/s, minb=314KB/s, maxb=411KB/s, mint=39836msec, maxt=52083msec

patched:
WRITE: io=163840KB, aggrb=10033KB/s, minb=1003KB/s, maxb=1124KB/s, mint=14565msec, maxt=16329msec

---
 fs/f2fs/data.c | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)
fs/f2fs/data.c +10 -3
index a737ca5..a0a5849 100644
@@ -1536,7 +1536,9 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter,
 	struct file *file = iocb->ki_filp;
 	struct address_space *mapping = file->f_mapping;
 	struct inode *inode = mapping->host;
+	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 	size_t count = iov_iter_count(iter);
+	int rw = iov_iter_rw(iter);
 	int err;
 
 	/* we don't need to use inline_data strictly */
@@ -1555,12 +1557,17 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter,
 
 	trace_f2fs_direct_IO_enter(inode, offset, count, iov_iter_rw(iter));
 
-	if (iov_iter_rw(iter) == WRITE)
+	if (rw == WRITE) {
+		mutex_lock(&sbi->writepages);
 		__allocate_data_blocks(inode, offset, count);
+	}
 
 	err = blockdev_direct_IO(iocb, inode, iter, offset, get_data_block_dio);
-	if (err < 0 && iov_iter_rw(iter) == WRITE)
-		f2fs_write_failed(mapping, offset + count);
+	if (rw == WRITE) {
+		mutex_unlock(&sbi->writepages);
+		if (err)
+			f2fs_write_failed(mapping, offset + count);
+	}
 
 	trace_f2fs_direct_IO_exit(inode, offset, count, iov_iter_rw(iter), err);
 
Signature · 1 line
2.4.2
maintainer
#1 lore raw

Hi Chao,

Quoted 45 lines · Chao Yu

When dio writes perform concurrently, our performace will be low because of Thread A's allocation of multi continuous blocks will be break by Thread B, there are two cases as below:
- In Thread B, we may change current segment to a new segment for LFS allocation if we dio write in the beginning of the file.
- In Thread B, we may allocate blocks in the middle of Thread A's allocation, which make blocks which allocated in Thread A being discontinuous.

This patch adds writepages mutex lock to make block allocation in dio write atomic to avoid above issues.

Test environment:
ubuntu os with linux kernel 4.2+, intel i7-3770, 16g memory, 32g kingston sd card.

fio --name seqw --ioengine=sync --invalidate=1 --rw=write --directory=/mnt/f2fs --filesize=256m --size=16m --bs=2m --direct=1 --numjobs=10

before:
WRITE: io=163840KB, aggrb=3145KB/s, minb=314KB/s, maxb=411KB/s, mint=39836msec, maxt=52083msec

patched:
WRITE: io=163840KB, aggrb=10033KB/s, minb=1003KB/s, maxb=1124KB/s, mint=14565msec, maxt=16329msec

---
 fs/f2fs/data.c | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)
fs/f2fs/data.c +2 -0
index a737ca5..a0a5849 100644
@@ -1536,7 +1536,9 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter,
 	struct file *file = iocb->ki_filp;
 	struct address_space *mapping = file->f_mapping;
 	struct inode *inode = mapping->host;
+	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 	size_t count = iov_iter_count(iter);
+	int rw = iov_iter_rw(iter);
 	int err;
 
 	/* we don't need to use inline_data strictly */

fs/f2fs/data.c static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter, · line 1561

Quoted 6 lines
fs/f2fs/data.c +2 -1
@@ -1555,12 +1557,17 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter,
 
 	trace_f2fs_direct_IO_enter(inode, offset, count, iov_iter_rw(iter));
 
-	if (iov_iter_rw(iter) == WRITE)
+	if (rw == WRITE) {
+		mutex_lock(&sbi->writepages);

Why do we have to share sbi->writepages?

fs/f2fs/data.c static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter, · line 1562

Quoted 1 line
fs/f2fs/data.c +0 -0
 		__allocate_data_blocks(inode, offset, count);

If the problem lies on the misaligned blocks, how about calling mutex_unlock here?

Thanks,

Quoted 15 lines
fs/f2fs/data.c +6 -2
+	}
 
 	err = blockdev_direct_IO(iocb, inode, iter, offset, get_data_block_dio);
-	if (err < 0 && iov_iter_rw(iter) == WRITE)
-		f2fs_write_failed(mapping, offset + count);
+	if (rw == WRITE) {
+		mutex_unlock(&sbi->writepages);
+		if (err)
+			f2fs_write_failed(mapping, offset + count);
+	}
 
 	trace_f2fs_direct_IO_exit(inode, offset, count, iov_iter_rw(iter), err);
 
Signature · 1 line
2.4.2
author
#2 lore raw

Hi Jaegeuk,

Quoted 60 lines

-----Original Message-----
From: Jaegeuk Kim [mailto:[email protected]]
Sent: Wednesday, September 16, 2015 5:21 AM
To: Chao Yu
Cc: [email protected]; [email protected]
Subject: Re: [PATCH 5/7] f2fs: enhance multithread dio write performance

Hi Chao,

Quoted 9 lines · Chao Yu

When dio writes perform concurrently, our performace will be low because of Thread A's allocation of multi continuous blocks will be break by Thread B, there are two cases as below:
- In Thread B, we may change current segment to a new segment for LFS allocation if we dio write in the beginning of the file.
- In Thread B, we may allocate blocks in the middle of Thread A's allocation, which make blocks which allocated in Thread A being discontinuous.

Quoted 8 lines

This patch adds writepages mutex lock to make block allocation in dio write atomic to avoid above issues.

Test environment:
ubuntu os with linux kernel 4.2+, intel i7-3770, 16g memory, 32g kingston sd card.

fio --name seqw --ioengine=sync --invalidate=1 --rw=write --directory=/mnt/f2fs

--filesize=256m --size=16m --bs=2m --direct=1

Quoted 4 lines

--numjobs=10

before:
WRITE: io=163840KB, aggrb=3145KB/s, minb=314KB/s, maxb=411KB/s, mint=39836msec,

maxt=52083msec

Quoted 3 lines

patched:
WRITE: io=163840KB, aggrb=10033KB/s, minb=1003KB/s, maxb=1124KB/s, mint=14565msec,

maxt=16329msec

fs/f2fs/data.c static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter

Quoted 21 lines
---
 fs/f2fs/data.c | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)
fs/f2fs/data.c +2 -0
index a737ca5..a0a5849 100644
@@ -1536,7 +1536,9 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter,
 	struct file *file = iocb->ki_filp;
 	struct address_space *mapping = file->f_mapping;
 	struct inode *inode = mapping->host;
+	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 	size_t count = iov_iter_count(iter);
+	int rw = iov_iter_rw(iter);
 	int err;
 
 	/* we don't need to use inline_data strictly */
@@ -1555,12 +1557,17 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter

*iter,

Quoted 1 line
Quoted 7 lines

fs/f2fs/data.c static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter, · line 1561

Quoted 5 lines
fs/f2fs/data.c +2 -1
 	trace_f2fs_direct_IO_enter(inode, offset, count, iov_iter_rw(iter));
 
-	if (iov_iter_rw(iter) == WRITE)
+	if (rw == WRITE) {
+		mutex_lock(&sbi->writepages);

Why do we have to share sbi->writepages?

The root cause of this issue is that: in f2fs, we have no suitable dispatcher which can do the following things as an atomic operation:
a) allocate position(s) in flash device for current block(s);
b) submit user data in allocated position(s) in block layer.

Without the dispatcher, we will suffer performance issue in following scenario:
Thread A Thread B Thread C
allocate pos+1
allocate pos+2
allocate pos+3
submit pos+1
submit pos+3
submit pos+2

Our final submitting series will: pos+1, pos+3, pos+2, this makes f2fs running into non-LFS mode, therefore resulting in bad performance.

writepages mutex lock supply us with a good solution for above issue. It not only make the allocating and submitting pair executing atomically, but also reduce the fragmentation for one file since we submit blocks belong to single inode as continuous as possible.

So here I choose to use writepages mutex lock to fix the performance issue caused by both dio write vs dio write and dio write vs buffered write.

If I'm missing something, please correct me.

Quoted 5 lines
Quoted 2 lines

__allocate_data_blocks(inode, offset, count);

If the problem lies on the misaligned blocks, how about calling mutex_unlock here?

When changing to unlock here, I got regression when testing with following command:
fio --name seqw --ioengine=sync --invalidate=1 --rw=write --directory=/mnt/f2fs --filesize=256m --size=4m --bs=64k --direct=1 --numjobs=20

unlock here:
WRITE: io=81920KB, aggrb=5802KB/s, minb=290KB/s, maxb=292KB/s, mint=14010msec, maxt=14119msec
unlock after dio finished:
WRITE: io=81920KB, aggrb=6088KB/s, minb=304KB/s, maxb=1081KB/s, mint=3786msec, maxt=13454msec

So how about keep it in original place in this patch?

Thanks,

Quoted 18 lines

Thanks,

Quoted 15 lines
fs/f2fs/data.c +6 -3
+	}
 
 	err = blockdev_direct_IO(iocb, inode, iter, offset, get_data_block_dio);
-	if (err < 0 && iov_iter_rw(iter) == WRITE)
-		f2fs_write_failed(mapping, offset + count);
+	if (rw == WRITE) {
+		mutex_unlock(&sbi->writepages);
+		if (err)
+			f2fs_write_failed(mapping, offset + count);
+	}
 
 	trace_f2fs_direct_IO_exit(inode, offset, count, iov_iter_rw(iter), err);
 
--

2.4.2

maintainer
#3 lore raw

Hi Chao,

Quoted 88 lines · Chao Yu

Hi Jaegeuk,

Quoted 60 lines

-----Original Message-----
From: Jaegeuk Kim [mailto:[email protected]]
Sent: Wednesday, September 16, 2015 5:21 AM
To: Chao Yu
Cc: [email protected]; [email protected]
Subject: Re: [PATCH 5/7] f2fs: enhance multithread dio write performance

Hi Chao,

Quoted 9 lines · Chao Yu

When dio writes perform concurrently, our performace will be low because of Thread A's allocation of multi continuous blocks will be break by Thread B, there are two cases as below:
- In Thread B, we may change current segment to a new segment for LFS allocation if we dio write in the beginning of the file.
- In Thread B, we may allocate blocks in the middle of Thread A's allocation, which make blocks which allocated in Thread A being discontinuous.

Quoted 8 lines

This patch adds writepages mutex lock to make block allocation in dio write atomic to avoid above issues.

Test environment:
ubuntu os with linux kernel 4.2+, intel i7-3770, 16g memory, 32g kingston sd card.

fio --name seqw --ioengine=sync --invalidate=1 --rw=write --directory=/mnt/f2fs

--filesize=256m --size=16m --bs=2m --direct=1

Quoted 4 lines

--numjobs=10

before:
WRITE: io=163840KB, aggrb=3145KB/s, minb=314KB/s, maxb=411KB/s, mint=39836msec,

maxt=52083msec

Quoted 3 lines

patched:
WRITE: io=163840KB, aggrb=10033KB/s, minb=1003KB/s, maxb=1124KB/s, mint=14565msec,

maxt=16329msec

fs/f2fs/data.c static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter

Quoted 21 lines
---
 fs/f2fs/data.c | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)
fs/f2fs/data.c +2 -0
index a737ca5..a0a5849 100644
@@ -1536,7 +1536,9 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter,
 	struct file *file = iocb->ki_filp;
 	struct address_space *mapping = file->f_mapping;
 	struct inode *inode = mapping->host;
+	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 	size_t count = iov_iter_count(iter);
+	int rw = iov_iter_rw(iter);
 	int err;
 
 	/* we don't need to use inline_data strictly */
@@ -1555,12 +1557,17 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter

*iter,

Quoted 1 line
Quoted 7 lines

fs/f2fs/data.c static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter, · line 1561

Quoted 5 lines
fs/f2fs/data.c +2 -1
 	trace_f2fs_direct_IO_enter(inode, offset, count, iov_iter_rw(iter));
 
-	if (iov_iter_rw(iter) == WRITE)
+	if (rw == WRITE) {
+		mutex_lock(&sbi->writepages);

Why do we have to share sbi->writepages?

The root cause of this issue is that: in f2fs, we have no suitable dispatcher which can do the following things as an atomic operation:
a) allocate position(s) in flash device for current block(s);
b) submit user data in allocated position(s) in block layer.

Without the dispatcher, we will suffer performance issue in following scenario:
Thread A Thread B Thread C
allocate pos+1
allocate pos+2
allocate pos+3
submit pos+1
submit pos+3
submit pos+2

Our final submitting series will: pos+1, pos+3, pos+2, this makes f2fs running into non-LFS mode, therefore resulting in bad performance.

Quoted 8 lines

writepages mutex lock supply us with a good solution for above issue. It not only make the allocating and submitting pair executing atomically, but also reduce the fragmentation for one file since we submit blocks belong to single inode as continuous as possible.

So here I choose to use writepages mutex lock to fix the performance issue caused by both dio write vs dio write and dio write vs buffered write.

Understood, but the concern was the multi-thread performance as you mentioned. If one thread throws a big dio request, anybody cannot write at all? How about adding some limits likewise f2fs_write_data_pages whieh is for example nr_pages_to_write?

Thanks,

Quoted 39 lines

If I'm missing something, please correct me.

Quoted 5 lines
Quoted 2 lines

__allocate_data_blocks(inode, offset, count);

If the problem lies on the misaligned blocks, how about calling mutex_unlock here?

When changing to unlock here, I got regression when testing with following command:
fio --name seqw --ioengine=sync --invalidate=1 --rw=write --directory=/mnt/f2fs --filesize=256m --size=4m --bs=64k --direct=1 --numjobs=20

unlock here:
WRITE: io=81920KB, aggrb=5802KB/s, minb=290KB/s, maxb=292KB/s, mint=14010msec, maxt=14119msec
unlock after dio finished:
WRITE: io=81920KB, aggrb=6088KB/s, minb=304KB/s, maxb=1081KB/s, mint=3786msec, maxt=13454msec

So how about keep it in original place in this patch?

Thanks,

Quoted 18 lines

Thanks,

Quoted 15 lines
fs/f2fs/data.c +6 -3
+	}
 
 	err = blockdev_direct_IO(iocb, inode, iter, offset, get_data_block_dio);
-	if (err < 0 && iov_iter_rw(iter) == WRITE)
-		f2fs_write_failed(mapping, offset + count);
+	if (rw == WRITE) {
+		mutex_unlock(&sbi->writepages);
+		if (err)
+			f2fs_write_failed(mapping, offset + count);
+	}
 
 	trace_f2fs_direct_IO_exit(inode, offset, count, iov_iter_rw(iter), err);
 
--

2.4.2

author
#4 lore raw

Hi Jaegeuk,

Quoted 104 lines

-----Original Message-----
From: Jaegeuk Kim [mailto:[email protected]]
Sent: Thursday, September 17, 2015 2:13 AM
To: Chao Yu
Cc: [email protected]; [email protected]
Subject: Re: [PATCH 5/7] f2fs: enhance multithread dio write performance

Hi Chao,

Quoted 45 lines · Chao Yu

Hi Jaegeuk,

Quoted 43 lines

-----Original Message-----
From: Jaegeuk Kim [mailto:[email protected]]
Sent: Wednesday, September 16, 2015 5:21 AM
To: Chao Yu
Cc: [email protected]; [email protected]
Subject: Re: [PATCH 5/7] f2fs: enhance multithread dio write performance

Hi Chao,

Quoted 9 lines · Chao Yu

When dio writes perform concurrently, our performace will be low because of Thread A's allocation of multi continuous blocks will be break by Thread B, there are two cases as below:
- In Thread B, we may change current segment to a new segment for LFS allocation if we dio write in the beginning of the file.
- In Thread B, we may allocate blocks in the middle of Thread A's allocation, which make blocks which allocated in Thread A being discontinuous.

Quoted 8 lines

This patch adds writepages mutex lock to make block allocation in dio write atomic to avoid above issues.

Test environment:
ubuntu os with linux kernel 4.2+, intel i7-3770, 16g memory, 32g kingston sd card.

fio --name seqw --ioengine=sync --invalidate=1 --rw=write --directory=/mnt/f2fs

--filesize=256m --size=16m --bs=2m --direct=1

Quoted 4 lines

--numjobs=10

before:
WRITE: io=163840KB, aggrb=3145KB/s, minb=314KB/s, maxb=411KB/s, mint=39836msec,

maxt=52083msec

Quoted 3 lines

patched:
WRITE: io=163840KB, aggrb=10033KB/s, minb=1003KB/s, maxb=1124KB/s, mint=14565msec,

maxt=16329msec

Quoted 6 lines
---
 fs/f2fs/data.c | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)
Quoted 5 lines
Quoted 5 lines

fs/f2fs/data.c static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter

Quoted 5 lines
fs/f2fs/data.c +0 -0
index a737ca5..a0a5849 100644
@@ -1536,7 +1536,9 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter

*iter,

Quoted 43 lines
Quoted 12 lines

fs/f2fs/data.c static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter

Quoted 10 lines
fs/f2fs/data.c +2 -0
 	struct file *file = iocb->ki_filp;
 	struct address_space *mapping = file->f_mapping;
 	struct inode *inode = mapping->host;
+	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 	size_t count = iov_iter_count(iter);
+	int rw = iov_iter_rw(iter);
 	int err;
 
 	/* we don't need to use inline_data strictly */
@@ -1555,12 +1557,17 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter

*iter,

Quoted 1 line
Quoted 7 lines

fs/f2fs/data.c static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter, · line 1561

Quoted 5 lines
fs/f2fs/data.c +2 -1
 	trace_f2fs_direct_IO_enter(inode, offset, count, iov_iter_rw(iter));
 
-	if (iov_iter_rw(iter) == WRITE)
+	if (rw == WRITE) {
+		mutex_lock(&sbi->writepages);

Why do we have to share sbi->writepages?

The root cause of this issue is that: in f2fs, we have no suitable dispatcher which can do the following things as an atomic operation:
a) allocate position(s) in flash device for current block(s);
b) submit user data in allocated position(s) in block layer.

Without the dispatcher, we will suffer performance issue in following scenario:
Thread A Thread B Thread C
allocate pos+1
allocate pos+2
allocate pos+3
submit pos+1
submit pos+3
submit pos+2

Our final submitting series will: pos+1, pos+3, pos+2, this makes f2fs running into non-LFS mode, therefore resulting in bad performance.

writepages mutex lock supply us with a good solution for above issue. It not only make the allocating and submitting pair executing atomically, but also reduce the fragmentation for one file since we submit blocks belong to single inode as continuous as possible.

Quoted 6 lines
Quoted 3 lines

So here I choose to use writepages mutex lock to fix the performance issue caused by both dio write vs dio write and dio write vs buffered write.

Understood, but the concern was the multi-thread performance as you mentioned. If one thread throws a big dio request, anybody cannot write at all?

Buffered write will not be stopped, but actually my way completely stops the concurrency of multithreads which are doing dio writes, for aspect of improving concurrency, moving mutex_unlock below __allocate_data_blocks is a good solution so far.

Quoted 2 lines

How about adding some limits likewise f2fs_write_data_pages whieh is for example nr_pages_to_write?

Could you share more details about your idea?

As Yunlei reported, there is performance regression issue, so how about holding this patch and let me do some investigation?

Thanks,

Quoted 45 lines

Thanks,

Quoted 11 lines

If I'm missing something, please correct me.

Quoted 5 lines
Quoted 2 lines

__allocate_data_blocks(inode, offset, count);

If the problem lies on the misaligned blocks, how about calling mutex_unlock here?

When changing to unlock here, I got regression when testing with following command:
fio --name seqw --ioengine=sync --invalidate=1 --rw=write --directory=/mnt/f2fs

--filesize=256m --size=4m --bs=64k --direct=1

Quoted 4 lines

--numjobs=20

unlock here:
WRITE: io=81920KB, aggrb=5802KB/s, minb=290KB/s, maxb=292KB/s, mint=14010msec,

maxt=14119msec

Quoted 2 lines

unlock after dio finished:
WRITE: io=81920KB, aggrb=6088KB/s, minb=304KB/s, maxb=1081KB/s, mint=3786msec,

maxt=13454msec

Quoted 22 lines

So how about keep it in original place in this patch?

Thanks,

Quoted 18 lines

Thanks,

Quoted 15 lines
fs/f2fs/data.c +6 -3
+	}
 
 	err = blockdev_direct_IO(iocb, inode, iter, offset, get_data_block_dio);
-	if (err < 0 && iov_iter_rw(iter) == WRITE)
-		f2fs_write_failed(mapping, offset + count);
+	if (rw == WRITE) {
+		mutex_unlock(&sbi->writepages);
+		if (err)
+			f2fs_write_failed(mapping, offset + count);
+	}
 
 	trace_f2fs_direct_IO_exit(inode, offset, count, iov_iter_rw(iter), err);
 
--

2.4.2

maintainer
#5 lore raw

Hi Chao,

Quoted 118 lines · Chao Yu

Hi Jaegeuk,

Quoted 104 lines

-----Original Message-----
From: Jaegeuk Kim [mailto:[email protected]]
Sent: Thursday, September 17, 2015 2:13 AM
To: Chao Yu
Cc: [email protected]; [email protected]
Subject: Re: [PATCH 5/7] f2fs: enhance multithread dio write performance

Hi Chao,

Quoted 45 lines · Chao Yu

Hi Jaegeuk,

Quoted 43 lines

-----Original Message-----
From: Jaegeuk Kim [mailto:[email protected]]
Sent: Wednesday, September 16, 2015 5:21 AM
To: Chao Yu
Cc: [email protected]; [email protected]
Subject: Re: [PATCH 5/7] f2fs: enhance multithread dio write performance

Hi Chao,

Quoted 9 lines · Chao Yu

When dio writes perform concurrently, our performace will be low because of Thread A's allocation of multi continuous blocks will be break by Thread B, there are two cases as below:
- In Thread B, we may change current segment to a new segment for LFS allocation if we dio write in the beginning of the file.
- In Thread B, we may allocate blocks in the middle of Thread A's allocation, which make blocks which allocated in Thread A being discontinuous.

Quoted 8 lines

This patch adds writepages mutex lock to make block allocation in dio write atomic to avoid above issues.

Test environment:
ubuntu os with linux kernel 4.2+, intel i7-3770, 16g memory, 32g kingston sd card.

fio --name seqw --ioengine=sync --invalidate=1 --rw=write --directory=/mnt/f2fs

--filesize=256m --size=16m --bs=2m --direct=1

Quoted 4 lines

--numjobs=10

before:
WRITE: io=163840KB, aggrb=3145KB/s, minb=314KB/s, maxb=411KB/s, mint=39836msec,

maxt=52083msec

Quoted 3 lines

patched:
WRITE: io=163840KB, aggrb=10033KB/s, minb=1003KB/s, maxb=1124KB/s, mint=14565msec,

maxt=16329msec

Quoted 6 lines
---
 fs/f2fs/data.c | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)
Quoted 5 lines
Quoted 5 lines

fs/f2fs/data.c static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter

Quoted 5 lines
fs/f2fs/data.c +0 -0
index a737ca5..a0a5849 100644
@@ -1536,7 +1536,9 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter

*iter,

Quoted 43 lines
Quoted 12 lines

fs/f2fs/data.c static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter

Quoted 10 lines
fs/f2fs/data.c +2 -0
 	struct file *file = iocb->ki_filp;
 	struct address_space *mapping = file->f_mapping;
 	struct inode *inode = mapping->host;
+	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 	size_t count = iov_iter_count(iter);
+	int rw = iov_iter_rw(iter);
 	int err;
 
 	/* we don't need to use inline_data strictly */
@@ -1555,12 +1557,17 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter

*iter,

Quoted 1 line
Quoted 7 lines

fs/f2fs/data.c static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter, · line 1561

Quoted 5 lines
fs/f2fs/data.c +2 -1
 	trace_f2fs_direct_IO_enter(inode, offset, count, iov_iter_rw(iter));
 
-	if (iov_iter_rw(iter) == WRITE)
+	if (rw == WRITE) {
+		mutex_lock(&sbi->writepages);

Why do we have to share sbi->writepages?

The root cause of this issue is that: in f2fs, we have no suitable dispatcher which can do the following things as an atomic operation:
a) allocate position(s) in flash device for current block(s);
b) submit user data in allocated position(s) in block layer.

Without the dispatcher, we will suffer performance issue in following scenario:
Thread A Thread B Thread C
allocate pos+1
allocate pos+2
allocate pos+3
submit pos+1
submit pos+3
submit pos+2

Our final submitting series will: pos+1, pos+3, pos+2, this makes f2fs running into non-LFS mode, therefore resulting in bad performance.

writepages mutex lock supply us with a good solution for above issue. It not only make the allocating and submitting pair executing atomically, but also reduce the fragmentation for one file since we submit blocks belong to single inode as continuous as possible.

Quoted 6 lines
Quoted 3 lines

So here I choose to use writepages mutex lock to fix the performance issue caused by both dio write vs dio write and dio write vs buffered write.

Understood, but the concern was the multi-thread performance as you mentioned. If one thread throws a big dio request, anybody cannot write at all?

Buffered write will not be stopped, but actually my way completely stops the concurrency of multithreads which are doing dio writes, for aspect of improving concurrency, moving mutex_unlock below __allocate_data_blocks is a good solution so far.

Quoted 7 lines
Quoted 2 lines

How about adding some limits likewise f2fs_write_data_pages whieh is for example nr_pages_to_write?

Could you share more details about your idea?

As Yunlei reported, there is performance regression issue, so how about holding this patch and let me do some investigation?

It seems there is a mutex overhead when handling a bunch of 4KB small dios. Hmm, I meant, how about serializing pretty long-sized dios only?

Quoted 48 lines

Thanks,

Quoted 45 lines

Thanks,

Quoted 11 lines

If I'm missing something, please correct me.

Quoted 5 lines
Quoted 2 lines

__allocate_data_blocks(inode, offset, count);

If the problem lies on the misaligned blocks, how about calling mutex_unlock here?

When changing to unlock here, I got regression when testing with following command:
fio --name seqw --ioengine=sync --invalidate=1 --rw=write --directory=/mnt/f2fs

--filesize=256m --size=4m --bs=64k --direct=1

Quoted 4 lines

--numjobs=20

unlock here:
WRITE: io=81920KB, aggrb=5802KB/s, minb=290KB/s, maxb=292KB/s, mint=14010msec,

maxt=14119msec

Quoted 2 lines

unlock after dio finished:
WRITE: io=81920KB, aggrb=6088KB/s, minb=304KB/s, maxb=1081KB/s, mint=3786msec,

maxt=13454msec

Quoted 22 lines

So how about keep it in original place in this patch?

Thanks,

Quoted 18 lines

Thanks,

Quoted 15 lines
fs/f2fs/data.c +6 -3
+	}
 
 	err = blockdev_direct_IO(iocb, inode, iter, offset, get_data_block_dio);
-	if (err < 0 && iov_iter_rw(iter) == WRITE)
-		f2fs_write_failed(mapping, offset + count);
+	if (rw == WRITE) {
+		mutex_unlock(&sbi->writepages);
+		if (err)
+			f2fs_write_failed(mapping, offset + count);
+	}
 
 	trace_f2fs_direct_IO_exit(inode, offset, count, iov_iter_rw(iter), err);
 
--

2.4.2

author
#6 lore raw

Hi Jaegeuk,

Quoted 131 lines

-----Original Message-----
From: Jaegeuk Kim [mailto:[email protected]]
Sent: Friday, September 18, 2015 1:49 AM
To: Chao Yu
Cc: [email protected]; [email protected]
Subject: Re: [PATCH 5/7] f2fs: enhance multithread dio write performance

Hi Chao,

Quoted 121 lines · Chao Yu

Hi Jaegeuk,

Quoted 104 lines

-----Original Message-----
From: Jaegeuk Kim [mailto:[email protected]]
Sent: Thursday, September 17, 2015 2:13 AM
To: Chao Yu
Cc: [email protected]; [email protected]
Subject: Re: [PATCH 5/7] f2fs: enhance multithread dio write performance

Hi Chao,

Quoted 45 lines · Chao Yu

Hi Jaegeuk,

Quoted 43 lines

-----Original Message-----
From: Jaegeuk Kim [mailto:[email protected]]
Sent: Wednesday, September 16, 2015 5:21 AM
To: Chao Yu
Cc: [email protected]; [email protected]
Subject: Re: [PATCH 5/7] f2fs: enhance multithread dio write performance

Hi Chao,

Quoted 9 lines · Chao Yu

When dio writes perform concurrently, our performace will be low because of Thread A's allocation of multi continuous blocks will be break by Thread B, there are two cases as below:
- In Thread B, we may change current segment to a new segment for LFS allocation if we dio write in the beginning of the file.
- In Thread B, we may allocate blocks in the middle of Thread A's allocation, which make blocks which allocated in Thread A being discontinuous.

Quoted 8 lines

This patch adds writepages mutex lock to make block allocation in dio write atomic to avoid above issues.

Test environment:
ubuntu os with linux kernel 4.2+, intel i7-3770, 16g memory, 32g kingston sd card.

fio --name seqw --ioengine=sync --invalidate=1 --rw=write --directory=/mnt/f2fs

--filesize=256m --size=16m --bs=2m --direct=1

Quoted 4 lines

--numjobs=10

before:
WRITE: io=163840KB, aggrb=3145KB/s, minb=314KB/s, maxb=411KB/s, mint=39836msec,

maxt=52083msec

Quoted 3 lines

patched:
WRITE: io=163840KB, aggrb=10033KB/s, minb=1003KB/s, maxb=1124KB/s, mint=14565msec,

maxt=16329msec

Quoted 6 lines
---
 fs/f2fs/data.c | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)
Quoted 5 lines
Quoted 5 lines

fs/f2fs/data.c static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter

Quoted 5 lines
fs/f2fs/data.c +0 -0
index a737ca5..a0a5849 100644
@@ -1536,7 +1536,9 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter

*iter,

Quoted 43 lines
Quoted 12 lines

fs/f2fs/data.c static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter

Quoted 10 lines
fs/f2fs/data.c +2 -0
 	struct file *file = iocb->ki_filp;
 	struct address_space *mapping = file->f_mapping;
 	struct inode *inode = mapping->host;
+	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 	size_t count = iov_iter_count(iter);
+	int rw = iov_iter_rw(iter);
 	int err;
 
 	/* we don't need to use inline_data strictly */
@@ -1555,12 +1557,17 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter

*iter,

Quoted 1 line
Quoted 7 lines

fs/f2fs/data.c static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter, · line 1561

Quoted 5 lines
fs/f2fs/data.c +2 -1
 	trace_f2fs_direct_IO_enter(inode, offset, count, iov_iter_rw(iter));
 
-	if (iov_iter_rw(iter) == WRITE)
+	if (rw == WRITE) {
+		mutex_lock(&sbi->writepages);

Why do we have to share sbi->writepages?

The root cause of this issue is that: in f2fs, we have no suitable dispatcher which can do the following things as an atomic operation:
a) allocate position(s) in flash device for current block(s);
b) submit user data in allocated position(s) in block layer.

Without the dispatcher, we will suffer performance issue in following scenario:
Thread A Thread B Thread C
allocate pos+1
allocate pos+2
allocate pos+3
submit pos+1
submit pos+3
submit pos+2

Our final submitting series will: pos+1, pos+3, pos+2, this makes f2fs running into non-LFS mode, therefore resulting in bad performance.

writepages mutex lock supply us with a good solution for above issue. It not only make the allocating and submitting pair executing atomically, but also reduce the fragmentation for one file since we submit blocks belong to single inode as continuous as possible.

Quoted 6 lines
Quoted 3 lines

So here I choose to use writepages mutex lock to fix the performance issue caused by both dio write vs dio write and dio write vs buffered write.

Understood, but the concern was the multi-thread performance as you mentioned. If one thread throws a big dio request, anybody cannot write at all?

Buffered write will not be stopped, but actually my way completely stops the concurrency of multithreads which are doing dio writes, for aspect of improving concurrency, moving mutex_unlock below __allocate_data_blocks is a good solution so far.

Quoted 2 lines

How about adding some limits likewise f2fs_write_data_pages whieh is for example nr_pages_to_write?

Quoted 7 lines
Quoted 4 lines

Could you share more details about your idea?

As Yunlei reported, there is performance regression issue, so how about holding this patch and let me do some investigation?

It seems there is a mutex overhead when handling a bunch of 4KB small dios. Hmm, I meant, how about serializing pretty long-sized dios only?

Oh, I got it, thanks for the idea. :)

I will take time to have a test.

Thanks,

Quoted 45 lines
Quoted 45 lines

Thanks,

Quoted 41 lines

Thanks,

Quoted 11 lines

If I'm missing something, please correct me.

Quoted 5 lines
Quoted 2 lines

__allocate_data_blocks(inode, offset, count);

If the problem lies on the misaligned blocks, how about calling mutex_unlock here?

When changing to unlock here, I got regression when testing with following command:
fio --name seqw --ioengine=sync --invalidate=1 --rw=write --directory=/mnt/f2fs

--filesize=256m --size=4m --bs=64k --direct=1

Quoted 4 lines

--numjobs=20

unlock here:
WRITE: io=81920KB, aggrb=5802KB/s, minb=290KB/s, maxb=292KB/s, mint=14010msec,

maxt=14119msec

Quoted 2 lines

unlock after dio finished:
WRITE: io=81920KB, aggrb=6088KB/s, minb=304KB/s, maxb=1081KB/s, mint=3786msec,

maxt=13454msec

Quoted 18 lines

So how about keep it in original place in this patch?

Thanks,

Quoted 14 lines

Thanks,

Quoted 11 lines
fs/f2fs/data.c +6 -2
+	}
 
 	err = blockdev_direct_IO(iocb, inode, iter, offset, get_data_block_dio);
-	if (err < 0 && iov_iter_rw(iter) == WRITE)
-		f2fs_write_failed(mapping, offset + count);
+	if (rw == WRITE) {
+		mutex_unlock(&sbi->writepages);
+		if (err)
+			f2fs_write_failed(mapping, offset + count);
+	}
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines

trace_f2fs_direct_IO_exit(inode, offset, count, iov_iter_rw(iter), err);

--
2.4.2

------------------------------------------------------------------------------

#7 lore raw
In reply to Chao Yu
Quoted 109 lines · Chao Yu

Hi Jaegeuk,

Quoted 60 lines

-----Original Message-----
From: Jaegeuk Kim [mailto:[email protected]]
Sent: Wednesday, September 16, 2015 5:21 AM
To: Chao Yu
Cc: [email protected]; [email protected]
Subject: Re: [PATCH 5/7] f2fs: enhance multithread dio write performance

Hi Chao,

Quoted 9 lines · Chao Yu

When dio writes perform concurrently, our performace will be low because of Thread A's allocation of multi continuous blocks will be break by Thread B, there are two cases as below:
- In Thread B, we may change current segment to a new segment for LFS allocation if we dio write in the beginning of the file.
- In Thread B, we may allocate blocks in the middle of Thread A's allocation, which make blocks which allocated in Thread A being discontinuous.

Quoted 8 lines

This patch adds writepages mutex lock to make block allocation in dio write atomic to avoid above issues.

Test environment:
ubuntu os with linux kernel 4.2+, intel i7-3770, 16g memory, 32g kingston sd card.

fio --name seqw --ioengine=sync --invalidate=1 --rw=write --directory=/mnt/f2fs

--filesize=256m --size=16m --bs=2m --direct=1

Quoted 4 lines

--numjobs=10

before:

   WRITE: io=163840KB, aggrb=3145KB/s, minb=314KB/s, maxb=411KB/s, mint=39836msec,

maxt=52083msec

Quoted 3 lines

patched:

   WRITE: io=163840KB, aggrb=10033KB/s, minb=1003KB/s, maxb=1124KB/s, mint=14565msec,

maxt=16329msec

fs/f2fs/data.c static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter

Quoted 21 lines
---
  fs/f2fs/data.c | 13 ++++++++++---
  1 file changed, 10 insertions(+), 3 deletions(-)
fs/f2fs/data.c +2 -0
index a737ca5..a0a5849 100644
@@ -1536,7 +1536,9 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter,
  	struct file *file = iocb->ki_filp;
  	struct address_space *mapping = file->f_mapping;
  	struct inode *inode = mapping->host;
+	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
  	size_t count = iov_iter_count(iter);
+	int rw = iov_iter_rw(iter);
  	int err;
 
  	/* we don't need to use inline_data strictly */
@@ -1555,12 +1557,17 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter

*iter,

Quoted 1 line
Quoted 7 lines

fs/f2fs/data.c static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter, · line 1561

Quoted 5 lines
  	trace_f2fs_direct_IO_enter(inode, offset, count, iov_iter_rw(iter));
fs/f2fs/data.c +2 -1
-	if (iov_iter_rw(iter) == WRITE)
+	if (rw == WRITE) {
+		mutex_lock(&sbi->writepages);

Why do we have to share sbi->writepages?

The root cause of this issue is that: in f2fs, we have no suitable dispatcher which can do the following things as an atomic operation:
a) allocate position(s) in flash device for current block(s);
b) submit user data in allocated position(s) in block layer.

Without the dispatcher, we will suffer performance issue in following scenario:
Thread A Thread B Thread C
allocate pos+1
allocate pos+2
allocate pos+3
submit pos+1
submit pos+3
submit pos+2

Our final submitting series will: pos+1, pos+3, pos+2, this makes f2fs running into non-LFS mode, therefore resulting in bad performance.

writepages mutex lock supply us with a good solution for above issue. It not only make the allocating and submitting pair executing atomically, but also reduce the fragmentation for one file since we submit blocks belong to single inode as continuous as possible.

So here I choose to use writepages mutex lock to fix the performance issue caused by both dio write vs dio write and dio write vs buffered write.

If I'm missing something, please correct me.

Quoted 5 lines
Quoted 2 lines
  		__allocate_data_blocks(inode, offset, count);

If the problem lies on the misaligned blocks, how about calling mutex_unlock here?

When changing to unlock here, I got regression when testing with following command:
fio --name seqw --ioengine=sync --invalidate=1 --rw=write --directory=/mnt/f2fs --filesize=256m --size=4m --bs=64k --direct=1 --numjobs=20

Quoted 6 lines

unlock here:

   WRITE: io=81920KB, aggrb=5802KB/s, minb=290KB/s, maxb=292KB/s, mint=14010msec, maxt=14119msec
unlock after dio finished:
   WRITE: io=81920KB, aggrb=6088KB/s, minb=304KB/s, maxb=1081KB/s, mint=3786msec, maxt=13454msec

So how about keep it in original place in this patch?

Does share writepages mutex lock have an effect on cache write? Here is AndroBench result on my phone:

Before patch:
1R1W 8R8W 16R16W
Sequential Write 161.31 163.85 154.67
Random Write 9.48 17.66 18.09

After patch:
1R1W 8R8W 16R16W
Sequential Write 159.61 157.24 160.11
Random Write 9.17 8.51 8.8

Unit:Mb/s, File size: 64M, Buffer size: 4k

Quoted 33 lines

Thanks,

Quoted 14 lines

Thanks,

Quoted 11 lines
fs/f2fs/data.c +6 -2
+	}
 
  	err = blockdev_direct_IO(iocb, inode, iter, offset, get_data_block_dio);
-	if (err < 0 && iov_iter_rw(iter) == WRITE)
-		f2fs_write_failed(mapping, offset + count);
+	if (rw == WRITE) {
+		mutex_unlock(&sbi->writepages);
+		if (err)
+			f2fs_write_failed(mapping, offset + count);
+	}
Quoted 4 lines
Quoted 4 lines
  	trace_f2fs_direct_IO_exit(inode, offset, count, iov_iter_rw(iter), err);

--
2.4.2

------------------------------------------------------------------------------
Monitor Your Dynamic Infrastructure at Any Scale With Datadog! Get real-time metrics from all of your servers, apps and tools in one place.
SourceForge users - Click here to start your Free Trial of Datadog now!
http://pubads.g.doubleclick.net/gampad/clk?id=241902991&iu=/4140
_______________________________________________
Linux-f2fs-devel mailing list [email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel

Quoted 2 lines

.

------------------------------------------------------------------------------
Monitor Your Dynamic Infrastructure at Any Scale With Datadog! Get real-time metrics from all of your servers, apps and tools in one place.
SourceForge users - Click here to start your Free Trial of Datadog now!
http://pubads.g.doubleclick.net/gampad/clk?id=241902991&iu=/4140

author
#8 lore raw

Hi Yunlei,

Quoted 137 lines

-----Original Message-----
From: He YunLei [mailto:[email protected]]
Sent: Thursday, September 17, 2015 8:40 AM
To: Chao Yu
Cc: 'Jaegeuk Kim'; [email protected]; [email protected]
Subject: Re: [f2fs-dev] [PATCH 5/7] f2fs: enhance multithread dio write performance

Quoted 45 lines · Chao Yu

Hi Jaegeuk,

Quoted 43 lines

-----Original Message-----
From: Jaegeuk Kim [mailto:[email protected]]
Sent: Wednesday, September 16, 2015 5:21 AM
To: Chao Yu
Cc: [email protected]; [email protected]
Subject: Re: [PATCH 5/7] f2fs: enhance multithread dio write performance

Hi Chao,

Quoted 9 lines · Chao Yu

When dio writes perform concurrently, our performace will be low because of Thread A's allocation of multi continuous blocks will be break by Thread B, there are two cases as below:
- In Thread B, we may change current segment to a new segment for LFS allocation if we dio write in the beginning of the file.
- In Thread B, we may allocate blocks in the middle of Thread A's allocation, which make blocks which allocated in Thread A being discontinuous.

Quoted 8 lines

This patch adds writepages mutex lock to make block allocation in dio write atomic to avoid above issues.

Test environment:
ubuntu os with linux kernel 4.2+, intel i7-3770, 16g memory, 32g kingston sd card.

fio --name seqw --ioengine=sync --invalidate=1 --rw=write --directory=/mnt/f2fs

--filesize=256m --size=16m --bs=2m --direct=1

Quoted 4 lines

--numjobs=10

before:

   WRITE: io=163840KB, aggrb=3145KB/s, minb=314KB/s, maxb=411KB/s, mint=39836msec,

maxt=52083msec

Quoted 3 lines

patched:

   WRITE: io=163840KB, aggrb=10033KB/s, minb=1003KB/s, maxb=1124KB/s, mint=14565msec,

maxt=16329msec

Quoted 6 lines
---
  fs/f2fs/data.c | 13 ++++++++++---
  1 file changed, 10 insertions(+), 3 deletions(-)
Quoted 5 lines
Quoted 5 lines

fs/f2fs/data.c static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter

Quoted 5 lines
fs/f2fs/data.c +0 -0
index a737ca5..a0a5849 100644
@@ -1536,7 +1536,9 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter

*iter,

Quoted 50 lines
Quoted 12 lines

fs/f2fs/data.c static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter

Quoted 10 lines
fs/f2fs/data.c +2 -0
  	struct file *file = iocb->ki_filp;
  	struct address_space *mapping = file->f_mapping;
  	struct inode *inode = mapping->host;
+	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
  	size_t count = iov_iter_count(iter);
+	int rw = iov_iter_rw(iter);
  	int err;
 
  	/* we don't need to use inline_data strictly */
@@ -1555,12 +1557,17 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter

*iter,

Quoted 1 line
Quoted 7 lines

fs/f2fs/data.c static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter, · line 1561

Quoted 5 lines
  	trace_f2fs_direct_IO_enter(inode, offset, count, iov_iter_rw(iter));
fs/f2fs/data.c +2 -1
-	if (iov_iter_rw(iter) == WRITE)
+	if (rw == WRITE) {
+		mutex_lock(&sbi->writepages);

Why do we have to share sbi->writepages?

The root cause of this issue is that: in f2fs, we have no suitable dispatcher which can do the following things as an atomic operation:
a) allocate position(s) in flash device for current block(s);
b) submit user data in allocated position(s) in block layer.

Without the dispatcher, we will suffer performance issue in following scenario:
Thread A Thread B Thread C
allocate pos+1
allocate pos+2
allocate pos+3
submit pos+1
submit pos+3
submit pos+2

Our final submitting series will: pos+1, pos+3, pos+2, this makes f2fs running into non-LFS mode, therefore resulting in bad performance.

writepages mutex lock supply us with a good solution for above issue. It not only make the allocating and submitting pair executing atomically, but also reduce the fragmentation for one file since we submit blocks belong to single inode as continuous as possible.

So here I choose to use writepages mutex lock to fix the performance issue caused by both dio write vs dio write and dio write vs buffered write.

If I'm missing something, please correct me.

Quoted 1 line
Quoted 7 lines
Quoted 4 lines
Quoted 1 line
  		__allocate_data_blocks(inode, offset, count);

If the problem lies on the misaligned blocks, how about calling mutex_unlock here?

When changing to unlock here, I got regression when testing with following command:
fio --name seqw --ioengine=sync --invalidate=1 --rw=write --directory=/mnt/f2fs

--filesize=256m --size=4m --bs=64k --direct=1

Quoted 4 lines

--numjobs=20

unlock here:

   WRITE: io=81920KB, aggrb=5802KB/s, minb=290KB/s, maxb=292KB/s, mint=14010msec,

maxt=14119msec

Quoted 2 lines

unlock after dio finished:

   WRITE: io=81920KB, aggrb=6088KB/s, minb=304KB/s, maxb=1081KB/s, mint=3786msec,

maxt=13454msec

Quoted 2 lines

So how about keep it in original place in this patch?

Does share writepages mutex lock have an effect on cache write? Here is AndroBench result on my phone:

Before patch:
1R1W 8R8W 16R16W
Sequential Write 161.31 163.85 154.67
Random Write 9.48 17.66 18.09

Quoted 4 lines

After patch:
1R1W 8R8W 16R16W
Sequential Write 159.61 157.24 160.11
Random Write 9.17 8.51 8.8

Thanks for your report, I will do the investigation.

Thanks,

Quoted 38 lines

Unit:Mb/s, File size: 64M, Buffer size: 4k

Quoted 35 lines

Thanks,

Quoted 14 lines

Thanks,

Quoted 11 lines
fs/f2fs/data.c +6 -2
+	}
 
  	err = blockdev_direct_IO(iocb, inode, iter, offset, get_data_block_dio);
-	if (err < 0 && iov_iter_rw(iter) == WRITE)
-		f2fs_write_failed(mapping, offset + count);
+	if (rw == WRITE) {
+		mutex_unlock(&sbi->writepages);
+		if (err)
+			f2fs_write_failed(mapping, offset + count);
+	}
Quoted 4 lines
Quoted 4 lines
  	trace_f2fs_direct_IO_exit(inode, offset, count, iov_iter_rw(iter), err);

--
2.4.2

------------------------------------------------------------------------------
Monitor Your Dynamic Infrastructure at Any Scale With Datadog! Get real-time metrics from all of your servers, apps and tools in one place.
SourceForge users - Click here to start your Free Trial of Datadog now!
http://pubads.g.doubleclick.net/gampad/clk?id=241902991&iu=/4140
_______________________________________________
Linux-f2fs-devel mailing list [email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel

.

author
#9 lore raw
In reply to He YunLei

Hi Yunlei,

Quoted 137 lines

-----Original Message-----
From: He YunLei [mailto:[email protected]]
Sent: Thursday, September 17, 2015 8:40 AM
To: Chao Yu
Cc: 'Jaegeuk Kim'; [email protected]; [email protected]
Subject: Re: [f2fs-dev] [PATCH 5/7] f2fs: enhance multithread dio write performance

Quoted 45 lines · Chao Yu

Hi Jaegeuk,

Quoted 43 lines

-----Original Message-----
From: Jaegeuk Kim [mailto:[email protected]]
Sent: Wednesday, September 16, 2015 5:21 AM
To: Chao Yu
Cc: [email protected]; [email protected]
Subject: Re: [PATCH 5/7] f2fs: enhance multithread dio write performance

Hi Chao,

Quoted 9 lines · Chao Yu

When dio writes perform concurrently, our performace will be low because of Thread A's allocation of multi continuous blocks will be break by Thread B, there are two cases as below:
- In Thread B, we may change current segment to a new segment for LFS allocation if we dio write in the beginning of the file.
- In Thread B, we may allocate blocks in the middle of Thread A's allocation, which make blocks which allocated in Thread A being discontinuous.

Quoted 8 lines

This patch adds writepages mutex lock to make block allocation in dio write atomic to avoid above issues.

Test environment:
ubuntu os with linux kernel 4.2+, intel i7-3770, 16g memory, 32g kingston sd card.

fio --name seqw --ioengine=sync --invalidate=1 --rw=write --directory=/mnt/f2fs

--filesize=256m --size=16m --bs=2m --direct=1

Quoted 4 lines

--numjobs=10

before:

   WRITE: io=163840KB, aggrb=3145KB/s, minb=314KB/s, maxb=411KB/s, mint=39836msec,

maxt=52083msec

Quoted 3 lines

patched:

   WRITE: io=163840KB, aggrb=10033KB/s, minb=1003KB/s, maxb=1124KB/s, mint=14565msec,

maxt=16329msec

Quoted 6 lines
---
  fs/f2fs/data.c | 13 ++++++++++---
  1 file changed, 10 insertions(+), 3 deletions(-)
Quoted 5 lines
Quoted 5 lines

fs/f2fs/data.c static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter

Quoted 5 lines
fs/f2fs/data.c +0 -0
index a737ca5..a0a5849 100644
@@ -1536,7 +1536,9 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter

*iter,

Quoted 50 lines
Quoted 12 lines

fs/f2fs/data.c static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter

Quoted 10 lines
fs/f2fs/data.c +2 -0
  	struct file *file = iocb->ki_filp;
  	struct address_space *mapping = file->f_mapping;
  	struct inode *inode = mapping->host;
+	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
  	size_t count = iov_iter_count(iter);
+	int rw = iov_iter_rw(iter);
  	int err;
 
  	/* we don't need to use inline_data strictly */
@@ -1555,12 +1557,17 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter

*iter,

Quoted 1 line
Quoted 7 lines

fs/f2fs/data.c

Quoted 5 lines
  	trace_f2fs_direct_IO_enter(inode, offset, count, iov_iter_rw(iter));
fs/f2fs/data.c +2 -1
-	if (iov_iter_rw(iter) == WRITE)
+	if (rw == WRITE) {
+		mutex_lock(&sbi->writepages);

Why do we have to share sbi->writepages?

The root cause of this issue is that: in f2fs, we have no suitable dispatcher which can do the following things as an atomic operation:
a) allocate position(s) in flash device for current block(s);
b) submit user data in allocated position(s) in block layer.

Without the dispatcher, we will suffer performance issue in following scenario:
Thread A Thread B Thread C
allocate pos+1
allocate pos+2
allocate pos+3
submit pos+1
submit pos+3
submit pos+2

Our final submitting series will: pos+1, pos+3, pos+2, this makes f2fs running into non-LFS mode, therefore resulting in bad performance.

writepages mutex lock supply us with a good solution for above issue. It not only make the allocating and submitting pair executing atomically, but also reduce the fragmentation for one file since we submit blocks belong to single inode as continuous as possible.

So here I choose to use writepages mutex lock to fix the performance issue caused by both dio write vs dio write and dio write vs buffered write.

If I'm missing something, please correct me.

Quoted 1 line
Quoted 7 lines
Quoted 4 lines
Quoted 1 line
  		__allocate_data_blocks(inode, offset, count);

If the problem lies on the misaligned blocks, how about calling mutex_unlock here?

When changing to unlock here, I got regression when testing with following command:
fio --name seqw --ioengine=sync --invalidate=1 --rw=write --directory=/mnt/f2fs

--filesize=256m --size=4m --bs=64k --direct=1

Quoted 4 lines

--numjobs=20

unlock here:

   WRITE: io=81920KB, aggrb=5802KB/s, minb=290KB/s, maxb=292KB/s, mint=14010msec,

maxt=14119msec

Quoted 2 lines

unlock after dio finished:

   WRITE: io=81920KB, aggrb=6088KB/s, minb=304KB/s, maxb=1081KB/s, mint=3786msec,

maxt=13454msec

Quoted 2 lines

So how about keep it in original place in this patch?

Does share writepages mutex lock have an effect on cache write? Here is AndroBench result on my phone:

Before patch:
1R1W 8R8W 16R16W
Sequential Write 161.31 163.85 154.67
Random Write 9.48 17.66 18.09

Quoted 6 lines

After patch:
1R1W 8R8W 16R16W
Sequential Write 159.61 157.24 160.11
Random Write 9.17 8.51 8.8

Unit:Mb/s, File size: 64M, Buffer size: 4k

Could you help to test the following patch?

Quoted 1 line

From 0abff8a16bf87076ec70a7c1b8da913000e9c3b7 Mon Sep 17 00:00:00 2001

From: Chao Yu <[email protected]>
Date: Wed, 21 Oct 2015 15:12:07 +0800
Subject: [PATCH v2] f2fs: enhance multithread dio write performance

When dio writes perform concurrently, our performace will be low because of Thread A's allocation of multi continuous blocks will be break by Thread B, there are two cases as below:
- In Thread B, we may change current segment to a new segment for LFS allocation if we dio write in the beginning of the file.
- In Thread B, we may allocate blocks in the middle of Thread A's allocation, which make blocks allocated in Thread A being inconsecutive.

This patch adds writepages mutex lock to make block allocation in dio write atomic to avoid above issues.

Test environment:
ubuntu os with linux kernel 4.4-rc4, intel i7-3770, 16g memory, 32g kingston sd card.

fio --name seqw --ioengine=sync --invalidate=1 --rw=write --directory=/mnt/f2fs --filesize=256m --size=16m --bs=2m --direct=1 --numjobs=10

before:
WRITE: io=163840KB, aggrb=5125KB/s, minb=512KB/s, maxb=776KB/s, mint=21105msec, maxt=31967msec
patched:
WRITE: io=163840KB, aggrb=10424KB/s, minb=1042KB/s, maxb=1172KB/s, mint=13975msec, maxt=15717msec

---
v2:
- only serialize block allocation.
- do not serialize small dio.

 fs/f2fs/data.c | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)
fs/f2fs/data.c +11 -4
index 90a2ffe..c01d113 100644
@@ -1566,7 +1566,10 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter,
 	struct file *file = iocb->ki_filp;
 	struct address_space *mapping = file->f_mapping;
 	struct inode *inode = mapping->host;
+	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 	size_t count = iov_iter_count(iter);
+	int rw = iov_iter_rw(iter);
+	bool serialized = (F2FS_BYTES_TO_BLK(count) >= 64);
 	int err;
 
 	/* we don't need to use inline_data strictly */
@@ -1583,10 +1586,14 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter,
 	if (err)
 		return err;
 
-	trace_f2fs_direct_IO_enter(inode, offset, count, iov_iter_rw(iter));
+	trace_f2fs_direct_IO_enter(inode, offset, count, rw);
 
-	if (iov_iter_rw(iter) == WRITE) {
+	if (rw == WRITE) {
+		if (serialized)
+			mutex_lock(&sbi->writepages);
 		__allocate_data_blocks(inode, offset, count);
+		if (serialized)
+			mutex_unlock(&sbi->writepages);
 		if (unlikely(f2fs_cp_error(F2FS_I_SB(inode)))) {
 			err = -EIO;
 			goto out;
@@ -1595,10 +1602,10 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter,
 
 	err = blockdev_direct_IO(iocb, inode, iter, offset, get_data_block_dio);
 out:
-	if (err < 0 && iov_iter_rw(iter) == WRITE)
+	if (err < 0 && rw == WRITE)
 		f2fs_write_failed(mapping, offset + count);
 
-	trace_f2fs_direct_IO_exit(inode, offset, count, iov_iter_rw(iter), err);
+	trace_f2fs_direct_IO_exit(inode, offset, count, rw, err);
 
 	return err;
 }
Signature · 1 line
2.6.3
Quoted 36 lines
Quoted 36 lines

Thanks,

Quoted 14 lines

Thanks,

Quoted 11 lines
fs/f2fs/data.c +6 -2
+	}
 
  	err = blockdev_direct_IO(iocb, inode, iter, offset, get_data_block_dio);
-	if (err < 0 && iov_iter_rw(iter) == WRITE)
-		f2fs_write_failed(mapping, offset + count);
+	if (rw == WRITE) {
+		mutex_unlock(&sbi->writepages);
+		if (err)
+			f2fs_write_failed(mapping, offset + count);
+	}
Quoted 4 lines
Quoted 4 lines
  	trace_f2fs_direct_IO_exit(inode, offset, count, iov_iter_rw(iter), err);

--
2.4.2

------------------------------------------------------------------------------
Monitor Your Dynamic Infrastructure at Any Scale With Datadog! Get real-time metrics from all of your servers, apps and tools in one place.
SourceForge users - Click here to start your Free Trial of Datadog now!
http://pubads.g.doubleclick.net/gampad/clk?id=241902991&iu=/4140
_______________________________________________
Linux-f2fs-devel mailing list [email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel

.