Btrfs: improve the performance of the csums lookup

It is very likely that there are several blocks in bio, it is very
inefficient if we get their csums one by one. This patch improves
this problem by getting the csums in batch.

According to the result of the following test, the execute time of
__btrfs_lookup_bio_sums() is down by ~28%(300us -> 217us).

 # dd if=<mnt>/file of=/dev/null bs=1M count=1024

Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Josef Bacik <jbacik@fusionio.com>

1 files changed, 17 insertions, 11 deletions

diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c
index 005c45db699e..1ddd728541ee 100644
--- a/fs/btrfs/ordered-data.c
+++ b/fs/btrfs/ordered-data.c
@@ -986,7 +986,7 @@ out:
  * be reclaimed before their checksum is actually put into the btree
  */
 int btrfs_find_ordered_sum(struct inode *inode, u64 offset, u64 disk_bytenr,
-                           u32 *sum)
+                           u32 *sum, int len)
 {
         struct btrfs_ordered_sum *ordered_sum;
         struct btrfs_sector_sum *sector_sums;
@@ -995,22 +995,28 @@ int btrfs_find_ordered_sum(struct inode *inode, u64 offset, u64 disk_bytenr,
         unsigned long num_sectors;
         unsigned long i;
         u32 sectorsize = BTRFS_I(inode)->root->sectorsize;
-        int ret = 1;
+        int index = 0;
 
         ordered = btrfs_lookup_ordered_extent(inode, offset);
         if (!ordered)
-                return 1;
+                return 0;
 
         spin_lock_irq(&tree->lock);
         list_for_each_entry_reverse(ordered_sum, &ordered->list, list) {
-                if (disk_bytenr >= ordered_sum->bytenr) {
-                        num_sectors = ordered_sum->len / sectorsize;
-                        sector_sums = ordered_sum->sums;
-                        for (i = 0; i < num_sectors; i++) {
+                if (disk_bytenr >= ordered_sum->bytenr &&
+                    disk_bytenr < ordered_sum->bytenr + ordered_sum->len) {
+                        i = (disk_bytenr - ordered_sum->bytenr) >>
+                            inode->i_sb->s_blocksize_bits;
+                        sector_sums = ordered_sum->sums + i;
+                        num_sectors = ordered_sum->len >>
+                                      inode->i_sb->s_blocksize_bits;
+                        for (; i < num_sectors; i++) {
                                 if (sector_sums[i].bytenr == disk_bytenr) {
-                                        *sum = sector_sums[i].sum;
-                                        ret = 0;
-                                        goto out;
+                                        sum[index] = sector_sums[i].sum;
+                                        index++;
+                                        if (index == len)
+                                                goto out;
+                                        disk_bytenr += sectorsize;
                                 }
                         }
                 }
@@ -1018,7 +1024,7 @@ int btrfs_find_ordered_sum(struct inode *inode, u64 offset, u64 disk_bytenr,
 out:
         spin_unlock_irq(&tree->lock);
         btrfs_put_ordered_extent(ordered);
-        return ret;
+        return index;
 }