* [PATCH 2/5] ext4: speed up group trim with the right free block count.
2011-07-01 15:27 ` [PATCH 1/5] ext4: fix trim length underflow with small trim length Tao Ma
@ 2011-07-01 15:27 ` Tao Ma
2011-07-11 4:06 ` Ted Ts'o
2011-07-01 15:27 ` [PATCH 3/5] ext4: Add new ext4 trim tracepoints Tao Ma
` (3 subsequent siblings)
4 siblings, 1 reply; 11+ messages in thread
From: Tao Ma @ 2011-07-01 15:27 UTC (permalink / raw)
To: linux-ext4; +Cc: tytso
From: Tao Ma <boyu.mt@taobao.com>
When we trim some free blocks in a group of ext4, we should
calculate the free blocks properly and check whether there are
enough freed blocks left for us to trim. Current solution will
only calculate free spaces if they are large for a trim which
isn't appropriate.
Let us see a small example:
a group has 1.5M free which are 300k, 300k, 300k, 300k, 300k.
And minblocks is 1M. With current solution, we have to iterate
the whole group since these 300k will never be subtracted from
1.5M. But actually we should exit after we find the first 2
free spaces since the left 3 chunks only sum up to 900K if we
subtract the first 600K although they can't be trimed.
Reviewed-by: Andreas Dilger <adilger@dilger.ca>
Signed-off-by: Tao Ma <boyu.mt@taobao.com>
---
fs/ext4/mballoc.c | 5 +++--
1 files changed, 3 insertions(+), 2 deletions(-)
diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
index 604b706..3bd06ca 100644
--- a/fs/ext4/mballoc.c
+++ b/fs/ext4/mballoc.c
@@ -4823,7 +4823,7 @@ ext4_trim_all_free(struct super_block *sb, ext4_group_t group,
ext4_grpblk_t minblocks)
{
void *bitmap;
- ext4_grpblk_t next, count = 0;
+ ext4_grpblk_t next, count = 0, free_count = 0;
struct ext4_buddy e4b;
int ret;
@@ -4850,6 +4850,7 @@ ext4_trim_all_free(struct super_block *sb, ext4_group_t group,
next - start, group, &e4b);
count += next - start;
}
+ free_count += next - start;
start = next + 1;
if (fatal_signal_pending(current)) {
@@ -4863,7 +4864,7 @@ ext4_trim_all_free(struct super_block *sb, ext4_group_t group,
ext4_lock_group(sb, group);
}
- if ((e4b.bd_info->bb_free - count) < minblocks)
+ if ((e4b.bd_info->bb_free - free_count) < minblocks)
break;
}
ext4_unlock_group(sb, group);
--
1.7.4
^ permalink raw reply related [flat|nested] 11+ messages in thread* Re: [PATCH 2/5] ext4: speed up group trim with the right free block count.
2011-07-01 15:27 ` [PATCH 2/5] ext4: speed up group trim with the right free block count Tao Ma
@ 2011-07-11 4:06 ` Ted Ts'o
0 siblings, 0 replies; 11+ messages in thread
From: Ted Ts'o @ 2011-07-11 4:06 UTC (permalink / raw)
To: Tao Ma; +Cc: linux-ext4
On Fri, Jul 01, 2011 at 11:27:53PM +0800, Tao Ma wrote:
> From: Tao Ma <boyu.mt@taobao.com>
>
> When we trim some free blocks in a group of ext4, we should
> calculate the free blocks properly and check whether there are
> enough freed blocks left for us to trim. Current solution will
> only calculate free spaces if they are large for a trim which
> isn't appropriate.
>
> Let us see a small example:
> a group has 1.5M free which are 300k, 300k, 300k, 300k, 300k.
> And minblocks is 1M. With current solution, we have to iterate
> the whole group since these 300k will never be subtracted from
> 1.5M. But actually we should exit after we find the first 2
> free spaces since the left 3 chunks only sum up to 900K if we
> subtract the first 600K although they can't be trimed.
>
> Reviewed-by: Andreas Dilger <adilger@dilger.ca>
> Signed-off-by: Tao Ma <boyu.mt@taobao.com>
Added to the ext4 tree, thanks.
- Ted
^ permalink raw reply [flat|nested] 11+ messages in thread
* [PATCH 3/5] ext4: Add new ext4 trim tracepoints
2011-07-01 15:27 ` [PATCH 1/5] ext4: fix trim length underflow with small trim length Tao Ma
2011-07-01 15:27 ` [PATCH 2/5] ext4: speed up group trim with the right free block count Tao Ma
@ 2011-07-01 15:27 ` Tao Ma
2011-07-11 4:07 ` Ted Ts'o
2011-07-01 15:27 ` [PATCH 4/5] ext4: Speed up FITRIM by recording flags in ext4_group_info Tao Ma
` (2 subsequent siblings)
4 siblings, 1 reply; 11+ messages in thread
From: Tao Ma @ 2011-07-01 15:27 UTC (permalink / raw)
To: linux-ext4; +Cc: tytso
From: Tao Ma <boyu.mt@taobao.com>
Add ext4_trim_extent and ext4_trim_all_free.
Reviewed-by: Lukas Czerner <lczerner@redhat.com>
Signed-off-by: Tao Ma <boyu.mt@taobao.com>
---
fs/ext4/mballoc.c | 4 +++
include/trace/events/ext4.h | 49 +++++++++++++++++++++++++++++++++++++++++++
2 files changed, 53 insertions(+), 0 deletions(-)
diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
index 3bd06ca..cf42fdd 100644
--- a/fs/ext4/mballoc.c
+++ b/fs/ext4/mballoc.c
@@ -4782,6 +4782,8 @@ static void ext4_trim_extent(struct super_block *sb, int start, int count,
{
struct ext4_free_extent ex;
+ trace_ext4_trim_extent(sb, group, start, count);
+
assert_spin_locked(ext4_group_lock_ptr(sb, group));
ex.fe_start = start;
@@ -4827,6 +4829,8 @@ ext4_trim_all_free(struct super_block *sb, ext4_group_t group,
struct ext4_buddy e4b;
int ret;
+ trace_ext4_trim_all_free(sb, group, start, max);
+
ret = ext4_mb_load_buddy(sb, group, &e4b);
if (ret) {
ext4_error(sb, "Error in loading buddy "
diff --git a/include/trace/events/ext4.h b/include/trace/events/ext4.h
index 5ce2b2f..c5a517c 100644
--- a/include/trace/events/ext4.h
+++ b/include/trace/events/ext4.h
@@ -1520,6 +1520,55 @@ TRACE_EVENT(ext4_load_inode,
(unsigned long) __entry->ino)
);
+DECLARE_EVENT_CLASS(ext4__trim,
+ TP_PROTO(struct super_block *sb,
+ ext4_group_t group,
+ ext4_grpblk_t start,
+ ext4_grpblk_t len),
+
+ TP_ARGS(sb, group, start, len),
+
+ TP_STRUCT__entry(
+ __field( int, dev_major )
+ __field( int, dev_minor )
+ __field( __u32, group )
+ __field( int, start )
+ __field( int, len )
+ ),
+
+ TP_fast_assign(
+ __entry->dev_major = MAJOR(sb->s_dev);
+ __entry->dev_minor = MINOR(sb->s_dev);
+ __entry->group = group;
+ __entry->start = start;
+ __entry->len = len;
+ ),
+
+ TP_printk("dev %d,%d group %u, start %d, len %d",
+ __entry->dev_major, __entry->dev_minor,
+ __entry->group, __entry->start, __entry->len)
+);
+
+DEFINE_EVENT(ext4__trim, ext4_trim_extent,
+
+ TP_PROTO(struct super_block *sb,
+ ext4_group_t group,
+ ext4_grpblk_t start,
+ ext4_grpblk_t len),
+
+ TP_ARGS(sb, group, start, len)
+);
+
+DEFINE_EVENT(ext4__trim, ext4_trim_all_free,
+
+ TP_PROTO(struct super_block *sb,
+ ext4_group_t group,
+ ext4_grpblk_t start,
+ ext4_grpblk_t len),
+
+ TP_ARGS(sb, group, start, len)
+);
+
#endif /* _TRACE_EXT4_H */
/* This part must be outside protection */
--
1.7.4
^ permalink raw reply related [flat|nested] 11+ messages in thread* [PATCH 4/5] ext4: Speed up FITRIM by recording flags in ext4_group_info.
2011-07-01 15:27 ` [PATCH 1/5] ext4: fix trim length underflow with small trim length Tao Ma
2011-07-01 15:27 ` [PATCH 2/5] ext4: speed up group trim with the right free block count Tao Ma
2011-07-01 15:27 ` [PATCH 3/5] ext4: Add new ext4 trim tracepoints Tao Ma
@ 2011-07-01 15:27 ` Tao Ma
2011-07-11 4:07 ` Ted Ts'o
2011-07-01 15:27 ` [PATCH 5/5] ext4: Change the wrong param comment for ext4_trim_all_free Tao Ma
2011-07-11 4:06 ` [PATCH 1/5] ext4: fix trim length underflow with small trim length Ted Ts'o
4 siblings, 1 reply; 11+ messages in thread
From: Tao Ma @ 2011-07-01 15:27 UTC (permalink / raw)
To: linux-ext4; +Cc: tytso, Lukas Czerner
From: Tao Ma <boyu.mt@taobao.com>
In ext4, when FITRIM is called every time, we iterate all the
groups and do trim one by one. It is a bit time wasting if the
group has been trimmed and there is no change since the last
trim.
So this patch adds a new flag in ext4_group_info->bb_state to
indicate that the group has been trimmed, and it will be cleared
if some blocks is freed(in release_blocks_on_commit). Another
trim_minlen is added in ext4_sb_info to record the last minlen
we use to trim the volume, so that if the caller provide a small
one, we will go on the trim regardless of the bb_state.
A simple test with my intel x25m ssd:
df -h shows:
/dev/sdb1 40G 21G 17G 56% /mnt/ext4
Block size: 4096
run the FITRIM with the following parameter:
range.start = 0;
range.len = UINT64_MAX;
range.minlen = 1048576;
without the patch:
[root@boyu-tm linux-2.6]# time ./ftrim /mnt/ext4/a
real 0m5.505s
user 0m0.000s
sys 0m1.224s
[root@boyu-tm linux-2.6]# time ./ftrim /mnt/ext4/a
real 0m5.359s
user 0m0.000s
sys 0m1.178s
[root@boyu-tm linux-2.6]# time ./ftrim /mnt/ext4/a
real 0m5.228s
user 0m0.000s
sys 0m1.151s
with the patch:
[root@boyu-tm linux-2.6]# time ./ftrim /mnt/ext4/a
real 0m5.625s
user 0m0.000s
sys 0m1.269s
[root@boyu-tm linux-2.6]# time ./ftrim /mnt/ext4/a
real 0m0.002s
user 0m0.000s
sys 0m0.001s
[root@boyu-tm linux-2.6]# time ./ftrim /mnt/ext4/a
real 0m0.002s
user 0m0.000s
sys 0m0.001s
A big improvement for the 2nd and 3rd run.
Even after I delete some big image files, it is still much
faster than iterating the whole disk.
[root@boyu-tm test]# time ./ftrim /mnt/ext4/a
real 0m1.217s
user 0m0.000s
sys 0m0.196s
Cc: Lukas Czerner <lczerner@redhat.com>
Reviewed-by: Andreas Dilger <adilger.kernel@dilger.ca>
Signed-off-by: Tao Ma <boyu.mt@taobao.com>
---
fs/ext4/ext4.h | 13 ++++++++++++-
fs/ext4/mballoc.c | 20 ++++++++++++++++++++
2 files changed, 32 insertions(+), 1 deletions(-)
diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index 1921392..5878a22 100644
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -1214,6 +1214,9 @@ struct ext4_sb_info {
/* Kernel thread for multiple mount protection */
struct task_struct *s_mmp_tsk;
+
+ /* record the last minlen when FITRIM is called. */
+ atomic_t s_last_trim_minblks;
};
static inline struct ext4_sb_info *EXT4_SB(struct super_block *sb)
@@ -2067,11 +2070,19 @@ struct ext4_group_info {
* 5 free 8-block regions. */
};
-#define EXT4_GROUP_INFO_NEED_INIT_BIT 0
+#define EXT4_GROUP_INFO_NEED_INIT_BIT 0
+#define EXT4_GROUP_INFO_WAS_TRIMMED_BIT 1
#define EXT4_MB_GRP_NEED_INIT(grp) \
(test_bit(EXT4_GROUP_INFO_NEED_INIT_BIT, &((grp)->bb_state)))
+#define EXT4_MB_GRP_WAS_TRIMMED(grp) \
+ (test_bit(EXT4_GROUP_INFO_WAS_TRIMMED_BIT, &((grp)->bb_state)))
+#define EXT4_MB_GRP_SET_TRIMMED(grp) \
+ (set_bit(EXT4_GROUP_INFO_WAS_TRIMMED_BIT, &((grp)->bb_state)))
+#define EXT4_MB_GRP_CLEAR_TRIMMED(grp) \
+ (clear_bit(EXT4_GROUP_INFO_WAS_TRIMMED_BIT, &((grp)->bb_state)))
+
#define EXT4_MAX_CONTENTION 8
#define EXT4_CONTENTION_THRESHOLD 2
diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
index cf42fdd..cecc304 100644
--- a/fs/ext4/mballoc.c
+++ b/fs/ext4/mballoc.c
@@ -2628,6 +2628,15 @@ static void release_blocks_on_commit(journal_t *journal, transaction_t *txn)
rb_erase(&entry->node, &(db->bb_free_root));
mb_free_blocks(NULL, &e4b, entry->start_blk, entry->count);
+ /*
+ * Clear the trimmed flag for the group so that the next
+ * ext4_trim_fs can trim it.
+ * If the volume is mounted with -o discard, online discard
+ * is supported and the free blocks will be trimmed online.
+ */
+ if (!test_opt(sb, DISCARD))
+ EXT4_MB_GRP_CLEAR_TRIMMED(db);
+
if (!db->bb_free_root.rb_node) {
/* No more items in the per group rb tree
* balance refcounts from ext4_mb_free_metadata()
@@ -4840,6 +4849,10 @@ ext4_trim_all_free(struct super_block *sb, ext4_group_t group,
bitmap = e4b.bd_bitmap;
ext4_lock_group(sb, group);
+ if (EXT4_MB_GRP_WAS_TRIMMED(e4b.bd_info) &&
+ minblocks >= atomic_read(&EXT4_SB(sb)->s_last_trim_minblks))
+ goto out;
+
start = (e4b.bd_info->bb_first_free > start) ?
e4b.bd_info->bb_first_free : start;
@@ -4871,6 +4884,10 @@ ext4_trim_all_free(struct super_block *sb, ext4_group_t group,
if ((e4b.bd_info->bb_free - free_count) < minblocks)
break;
}
+
+ if (!ret)
+ EXT4_MB_GRP_SET_TRIMMED(e4b.bd_info);
+out:
ext4_unlock_group(sb, group);
ext4_mb_unload_buddy(&e4b);
@@ -4959,6 +4976,9 @@ int ext4_trim_fs(struct super_block *sb, struct fstrim_range *range)
}
range->len = trimmed * sb->s_blocksize;
+ if (!ret)
+ atomic_set(&EXT4_SB(sb)->s_last_trim_minblks, minlen);
+
out:
return ret;
}
--
1.7.4
^ permalink raw reply related [flat|nested] 11+ messages in thread* Re: [PATCH 4/5] ext4: Speed up FITRIM by recording flags in ext4_group_info.
2011-07-01 15:27 ` [PATCH 4/5] ext4: Speed up FITRIM by recording flags in ext4_group_info Tao Ma
@ 2011-07-11 4:07 ` Ted Ts'o
0 siblings, 0 replies; 11+ messages in thread
From: Ted Ts'o @ 2011-07-11 4:07 UTC (permalink / raw)
To: Tao Ma; +Cc: linux-ext4, Lukas Czerner
On Fri, Jul 01, 2011 at 11:27:55PM +0800, Tao Ma wrote:
> From: Tao Ma <boyu.mt@taobao.com>
>
> In ext4, when FITRIM is called every time, we iterate all the
> groups and do trim one by one. It is a bit time wasting if the
> group has been trimmed and there is no change since the last
> trim.
>
> So this patch adds a new flag in ext4_group_info->bb_state to
> indicate that the group has been trimmed, and it will be cleared
> if some blocks is freed(in release_blocks_on_commit). Another
> trim_minlen is added in ext4_sb_info to record the last minlen
> we use to trim the volume, so that if the caller provide a small
> one, we will go on the trim regardless of the bb_state.
Added to the ext4 tree, thanks.
- Ted
^ permalink raw reply [flat|nested] 11+ messages in thread
* [PATCH 5/5] ext4: Change the wrong param comment for ext4_trim_all_free.
2011-07-01 15:27 ` [PATCH 1/5] ext4: fix trim length underflow with small trim length Tao Ma
` (2 preceding siblings ...)
2011-07-01 15:27 ` [PATCH 4/5] ext4: Speed up FITRIM by recording flags in ext4_group_info Tao Ma
@ 2011-07-01 15:27 ` Tao Ma
2011-07-11 4:07 ` Ted Ts'o
2011-07-11 4:06 ` [PATCH 1/5] ext4: fix trim length underflow with small trim length Ted Ts'o
4 siblings, 1 reply; 11+ messages in thread
From: Tao Ma @ 2011-07-01 15:27 UTC (permalink / raw)
To: linux-ext4; +Cc: tytso
From: Tao Ma <boyu.mt@taobao.com>
at ext4_trim_all_free() comment, there is no longer an @e4b parameter,
instead it is @group.
Reported-by: Andreas Dilger <adilger@dilger.ca>
Signed-off-by: Tao Ma <boyu.mt@taobao.com>
---
fs/ext4/mballoc.c | 2 +-
1 files changed, 1 insertions(+), 1 deletions(-)
diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
index cecc304..9a35263 100644
--- a/fs/ext4/mballoc.c
+++ b/fs/ext4/mballoc.c
@@ -4813,7 +4813,7 @@ static void ext4_trim_extent(struct super_block *sb, int start, int count,
/**
* ext4_trim_all_free -- function to trim all free space in alloc. group
* @sb: super block for file system
- * @e4b: ext4 buddy
+ * @group: group to be trimmed
* @start: first group block to examine
* @max: last group block to examine
* @minblocks: minimum extent block count
--
1.7.4
^ permalink raw reply related [flat|nested] 11+ messages in thread* Re: [PATCH 1/5] ext4: fix trim length underflow with small trim length.
2011-07-01 15:27 ` [PATCH 1/5] ext4: fix trim length underflow with small trim length Tao Ma
` (3 preceding siblings ...)
2011-07-01 15:27 ` [PATCH 5/5] ext4: Change the wrong param comment for ext4_trim_all_free Tao Ma
@ 2011-07-11 4:06 ` Ted Ts'o
4 siblings, 0 replies; 11+ messages in thread
From: Ted Ts'o @ 2011-07-11 4:06 UTC (permalink / raw)
To: Tao Ma; +Cc: linux-ext4, Lukas Czerner
On Fri, Jul 01, 2011 at 11:27:52PM +0800, Tao Ma wrote:
> From: Tao Ma <boyu.mt@taobao.com>
>
> In 0f0a25b, we adjust 'len' with s_first_data_block - start, but
> it could underflow in case blocksize=1K, fstrim_range.len=512 and
> fstrim_range.start = 0. In this case, when we run the code:
> len -= first_data_blk - start; len will be underflow to -1ULL.
> In the end, although we are safe that last_group check later will limit
> the trim to the whole volume, but that isn't what the user really want.
>
> So this patch fix it. It also adds the check for 'start' like ext3 so that
> we can break immediately if the start is invalid.
>
> Cc: Lukas Czerner <lczerner@redhat.com>
> Signed-off-by: Tao Ma <boyu.mt@taobao.com>
Added to the ext4 tree, thanks.
- Ted
^ permalink raw reply [flat|nested] 11+ messages in thread