f2fs: check return value of write_checkpoint during fstrim

From: Chao Yu <[email protected]>

In batch discard approach of fstrim will grab/release gc_mutex lock repeatly, it makes contention of the lock becoming more intensive.

So after one batch discards were issued in checkpoint and the lock was released, it's better to do schedule() to increase opportunity of grabbing gc_mutex lock for other competitors.

Signed-off-by Chao Yu <[email protected]>

---
 fs/f2fs/segment.c | 2 ++
 1 file changed, 2 insertions(+)

fs/f2fs/segment.c +0 -0

index 020767c..d0f74eb 100644

fs/f2fs/segment.c +0 -0

 	}
 out:
 	range->len = F2FS_BLK_TO_BYTES(cpc.trimmed);

Signature · 1 line

2.7.2

Hi Chao,

Quoted 14 lines · Chao Yu

From: Chao Yu <[email protected]>

In batch discard approach of fstrim will grab/release gc_mutex lock repeatly, it makes contention of the lock becoming more intensive.

So after one batch discards were issued in checkpoint and the lock was released, it's better to do schedule() to increase opportunity of grabbing gc_mutex lock for other competitors.

Signed-off-by Chao Yu <[email protected]>

---
 fs/f2fs/segment.c | 2 ++
 1 file changed, 2 insertions(+)

fs/f2fs/segment.c int f2fs_trim_fs(struct f2fs_sb_info *sbi, struct fstrim_range *range) · line 1309

Quoted 10 lines

fs/f2fs/segment.c +2 -0

index 020767c..d0f74eb 100644
@@ -1305,6 +1305,8 @@ int f2fs_trim_fs(struct f2fs_sb_info *sbi, struct fstrim_range *range)
 		mutex_unlock(&sbi->gc_mutex);
 		if (err)
 			break;
+
+		schedule();

Hmm, if other thread is already waiting for gc_mutex, we don't need this here. In order to avoid long latency, wouldn't it be enough to reduce the batch size?

Thanks,

Quoted 5 lines

fs/f2fs/segment.c +0 -0

 	}
 out:
 	range->len = F2FS_BLK_TO_BYTES(cpc.trimmed);

Signature · 1 line

2.7.2

.

Hi Jaegeuk,

Quoted 17 lines · Jaegeuk Kim

Hi Chao,

Quoted 14 lines · Chao Yu

From: Chao Yu <[email protected]>

In batch discard approach of fstrim will grab/release gc_mutex lock repeatly, it makes contention of the lock becoming more intensive.

So after one batch discards were issued in checkpoint and the lock was released, it's better to do schedule() to increase opportunity of grabbing gc_mutex lock for other competitors.

Signed-off-by Chao Yu <[email protected]>

---
 fs/f2fs/segment.c | 2 ++
 1 file changed, 2 insertions(+)

Quoted 13 lines

fs/f2fs/segment.c int f2fs_trim_fs(struct f2fs_sb_info *sbi, struct fstrim_range *range) · line 1309

Quoted 10 lines

fs/f2fs/segment.c +2 -0

index 020767c..d0f74eb 100644
@@ -1305,6 +1305,8 @@ int f2fs_trim_fs(struct f2fs_sb_info *sbi, struct fstrim_range *range)
 		mutex_unlock(&sbi->gc_mutex);
 		if (err)
 			break;
+
+		schedule();

Hmm, if other thread is already waiting for gc_mutex, we don't need this here. In order to avoid long latency, wouldn't it be enough to reduce the batch size?

Hmm, when fstrim call mutex_unlock we will pop one blocked locker from FIFO list of mutex lock, and wake it up, then fstrimer will try to lock gc_mutex for next batch trim, so the popped locker and fstrimer will make a new competition in gc_mutex.

If fstrimer is running in a big core, and popped locker is running in a small core, we can't guarantee popped locker can win the race, and for the most of time, fstrimer will win. So in order to reduce starvation of other gc_mutext locker, it's better to do schedule() here.

Thanks,

Quoted 11 lines

Thanks,

Quoted 5 lines

fs/f2fs/segment.c +0 -0

 	}
 out:
 	range->len = F2FS_BLK_TO_BYTES(cpc.trimmed);

Signature · 1 line

2.7.2

.

Hi Chao,

Quoted 34 lines · Chao Yu

Hi Jaegeuk,

Quoted 30 lines · Jaegeuk Kim

Hi Chao,

Quoted 19 lines · Chao Yu

From: Chao Yu <[email protected]>

In batch discard approach of fstrim will grab/release gc_mutex lock repeatly, it makes contention of the lock becoming more intensive.

So after one batch discards were issued in checkpoint and the lock was released, it's better to do schedule() to increase opportunity of grabbing gc_mutex lock for other competitors.

Signed-off-by Chao Yu <[email protected]>

---
 fs/f2fs/segment.c | 2 ++
 1 file changed, 2 insertions(+)

fs/f2fs/segment.c +0 -0

index 020767c..d0f74eb 100644

fs/f2fs/segment.c int f2fs_trim_fs(struct f2fs_sb_info *sbi, struct fstrim_range *range) · line 1309

Quoted 5 lines

fs/f2fs/segment.c +2 -0

@@ -1305,6 +1305,8 @@ int f2fs_trim_fs(struct f2fs_sb_info *sbi, struct fstrim_range *range)
 		mutex_unlock(&sbi->gc_mutex);
 		if (err)
 			break;
+
+		schedule();

Hmm, if other thread is already waiting for gc_mutex, we don't need this here. In order to avoid long latency, wouldn't it be enough to reduce the batch size?

Quoted 4 lines

Hmm, when fstrim call mutex_unlock we will pop one blocked locker from FIFO list of mutex lock, and wake it up, then fstrimer will try to lock gc_mutex for next batch trim, so the popped locker and fstrimer will make a new competition in gc_mutex.

Before trying to grab gc_mutex by fstrim again, there are already blocked tasks waiting for gc_mutex. Hence the next one should be selectec by FIFO, no?

Thanks,

Quoted 5 lines

If fstrimer is running in a big core, and popped locker is running in a small core, we can't guarantee popped locker can win the race, and for the most of time, fstrimer will win. So in order to reduce starvation of other gc_mutext locker, it's better to do schedule() here.

Quoted 13 lines

Thanks,

Quoted 11 lines

Thanks,

Quoted 5 lines

fs/f2fs/segment.c +0 -0

 	}
 out:
 	range->len = F2FS_BLK_TO_BYTES(cpc.trimmed);

Signature · 1 line

2.7.2

.

.

Hi Jaegeuk,

Quoted 42 lines · Jaegeuk Kim

Hi Chao,

Quoted 38 lines · Chao Yu

Hi Jaegeuk,

Quoted 17 lines · Jaegeuk Kim

Hi Chao,

Quoted 14 lines · Chao Yu

From: Chao Yu <[email protected]>

In batch discard approach of fstrim will grab/release gc_mutex lock repeatly, it makes contention of the lock becoming more intensive.

So after one batch discards were issued in checkpoint and the lock was released, it's better to do schedule() to increase opportunity of grabbing gc_mutex lock for other competitors.

Signed-off-by Chao Yu <[email protected]>

---
 fs/f2fs/segment.c | 2 ++
 1 file changed, 2 insertions(+)

Quoted 13 lines

fs/f2fs/segment.c int f2fs_trim_fs(struct f2fs_sb_info *sbi, struct fstrim_range *range) · line 1309

Quoted 10 lines

fs/f2fs/segment.c +2 -0

index 020767c..d0f74eb 100644
@@ -1305,6 +1305,8 @@ int f2fs_trim_fs(struct f2fs_sb_info *sbi, struct fstrim_range *range)
 		mutex_unlock(&sbi->gc_mutex);
 		if (err)
 			break;
+
+		schedule();

Hmm, if other thread is already waiting for gc_mutex, we don't need this here. In order to avoid long latency, wouldn't it be enough to reduce the batch size?

Hmm, when fstrim call mutex_unlock we will pop one blocked locker from FIFO list of mutex lock, and wake it up, then fstrimer will try to lock gc_mutex for next batch trim, so the popped locker and fstrimer will make a new competition in gc_mutex.

Quoted 2 lines

Before trying to grab gc_mutex by fstrim again, there are already blocked tasks waiting for gc_mutex. Hence the next one should be selectec by FIFO, no?

The next one which is going to be waked up is selected by FIFO, but the waked one is still needs to be race with other mutex lock grabber.

So there is no such guarantee that the waked one must get the lock.

Thanks,

Quoted 24 lines

Thanks,

Quoted 5 lines

If fstrimer is running in a big core, and popped locker is running in a small core, we can't guarantee popped locker can win the race, and for the most of time, fstrimer will win. So in order to reduce starvation of other gc_mutext locker, it's better to do schedule() here.

Quoted 13 lines

Thanks,

Quoted 11 lines

Thanks,

Quoted 5 lines

fs/f2fs/segment.c +0 -0

 	}
 out:
 	range->len = F2FS_BLK_TO_BYTES(cpc.trimmed);

Signature · 1 line

2.7.2

.

.