introduce-aging-to-extent-status-tree

   1 ext4: introduce aging to extent status tree
   2
   3 From: Jan Kara <jack@suse.cz>
   4
   5 Introduce a simple aging to extent status tree. Each extent has a
   6 REFERENCED bit which gets set when the extent is used. Shrinker then
   7 skips entries with referenced bit set and clears the bit. Thus
   8 frequently used extents have higher chances of staying in memory.
   9
  10 Signed-off-by: Jan Kara <jack@suse.cz>
  11 Signed-off-by: Theodore Ts'o <tytso@mit.edu>
  12 ---
  13  fs/ext4/extents_status.c | 22 +++++++++++++++++-----
  14  fs/ext4/extents_status.h | 35 +++++++++++++++++++++++++++++++----
  15  2 files changed, 48 insertions(+), 9 deletions(-)
  16
  17 diff --git a/fs/ext4/extents_status.c b/fs/ext4/extents_status.c
  18 index 30596498ed0b..e04d45733976 100644
  19 --- a/fs/ext4/extents_status.c
  20 +++ b/fs/ext4/extents_status.c
  21 @@ -382,7 +382,7 @@ static void ext4_es_free_extent(struct inode *inode, struct extent_status *es)
  22  static int ext4_es_can_be_merged(struct extent_status *es1,
  23                                  struct extent_status *es2)
  24  {
  25 -       if (ext4_es_status(es1) != ext4_es_status(es2))
  26 +       if (ext4_es_type(es1) != ext4_es_type(es2))
  27                 return 0;
  28
  29         if (((__u64) es1->es_len) + es2->es_len > EXT_MAX_BLOCKS) {
  30 @@ -425,6 +425,8 @@ ext4_es_try_to_merge_left(struct inode *inode, struct extent_status *es)
  31         es1 = rb_entry(node, struct extent_status, rb_node);
  32         if (ext4_es_can_be_merged(es1, es)) {
  33                 es1->es_len += es->es_len;
  34 +               if (ext4_es_is_referenced(es))
  35 +                       ext4_es_set_referenced(es1);
  36                 rb_erase(&es->rb_node, &tree->root);
  37                 ext4_es_free_extent(inode, es);
  38                 es = es1;
  39 @@ -447,6 +449,8 @@ ext4_es_try_to_merge_right(struct inode *inode, struct extent_status *es)
  40         es1 = rb_entry(node, struct extent_status, rb_node);
  41         if (ext4_es_can_be_merged(es, es1)) {
  42                 es->es_len += es1->es_len;
  43 +               if (ext4_es_is_referenced(es1))
  44 +                       ext4_es_set_referenced(es);
  45                 rb_erase(node, &tree->root);
  46                 ext4_es_free_extent(inode, es1);
  47         }
  48 @@ -813,6 +817,8 @@ out:
  49                 es->es_lblk = es1->es_lblk;
  50                 es->es_len = es1->es_len;
  51                 es->es_pblk = es1->es_pblk;
  52 +               if (!ext4_es_is_referenced(es))
  53 +                       ext4_es_set_referenced(es);
  54                 stats->es_stats_cache_hits++;
  55         } else {
  56                 stats->es_stats_cache_misses++;
  57 @@ -1252,11 +1258,17 @@ static int es_do_reclaim_extents(struct ext4_inode_info *ei, ext4_lblk_t end,
  58                  * We can't reclaim delayed extent from status tree because
  59                  * fiemap, bigallic, and seek_data/hole need to use it.
  60                  */
  61 -               if (!ext4_es_is_delayed(es)) {
  62 -                       rb_erase(&es->rb_node, &tree->root);
  63 -                       ext4_es_free_extent(inode, es);
  64 -                       (*nr_shrunk)++;
  65 +               if (ext4_es_is_delayed(es))
  66 +                       goto next;
  67 +               if (ext4_es_is_referenced(es)) {
  68 +                       ext4_es_clear_referenced(es);
  69 +                       goto next;
  70                 }
  71 +
  72 +               rb_erase(&es->rb_node, &tree->root);
  73 +               ext4_es_free_extent(inode, es);
  74 +               (*nr_shrunk)++;
  75 +next:
  76                 if (!node)
  77                         goto out_wrap;
  78                 es = rb_entry(node, struct extent_status, rb_node);
  79 diff --git a/fs/ext4/extents_status.h b/fs/ext4/extents_status.h
  80 index e86b1f34cfec..691b52613ce4 100644
  81 --- a/fs/ext4/extents_status.h
  82 +++ b/fs/ext4/extents_status.h
  83 @@ -34,6 +34,7 @@ enum {
  84         ES_UNWRITTEN_B,
  85         ES_DELAYED_B,
  86         ES_HOLE_B,
  87 +       ES_REFERENCED_B,
  88         ES_FLAGS
  89  };
  90
  91 @@ -44,6 +45,12 @@ enum {
  92  #define EXTENT_STATUS_UNWRITTEN (1 << ES_UNWRITTEN_B)
  93  #define EXTENT_STATUS_DELAYED  (1 << ES_DELAYED_B)
  94  #define EXTENT_STATUS_HOLE     (1 << ES_HOLE_B)
  95 +#define EXTENT_STATUS_REFERENCED       (1 << ES_REFERENCED_B)
  96 +
  97 +#define ES_TYPE_MASK   ((ext4_fsblk_t)(EXTENT_STATUS_WRITTEN | \
  98 +                         EXTENT_STATUS_UNWRITTEN | \
  99 +                         EXTENT_STATUS_DELAYED | \
 100 +                         EXTENT_STATUS_HOLE) << ES_SHIFT)
 101
 102  struct ext4_sb_info;
 103  struct ext4_extent;
 104 @@ -93,24 +100,44 @@ static inline unsigned int ext4_es_status(struct extent_status *es)
 105         return es->es_pblk >> ES_SHIFT;
 106  }
 107
 108 +static inline unsigned int ext4_es_type(struct extent_status *es)
 109 +{
 110 +       return (es->es_pblk & ES_TYPE_MASK) >> ES_SHIFT;
 111 +}
 112 +
 113  static inline int ext4_es_is_written(struct extent_status *es)
 114  {
 115 -       return (ext4_es_status(es) & EXTENT_STATUS_WRITTEN) != 0;
 116 +       return (ext4_es_type(es) & EXTENT_STATUS_WRITTEN) != 0;
 117  }
 118
 119  static inline int ext4_es_is_unwritten(struct extent_status *es)
 120  {
 121 -       return (ext4_es_status(es) & EXTENT_STATUS_UNWRITTEN) != 0;
 122 +       return (ext4_es_type(es) & EXTENT_STATUS_UNWRITTEN) != 0;
 123  }
 124
 125  static inline int ext4_es_is_delayed(struct extent_status *es)
 126  {
 127 -       return (ext4_es_status(es) & EXTENT_STATUS_DELAYED) != 0;
 128 +       return (ext4_es_type(es) & EXTENT_STATUS_DELAYED) != 0;
 129  }
 130
 131  static inline int ext4_es_is_hole(struct extent_status *es)
 132  {
 133 -       return (ext4_es_status(es) & EXTENT_STATUS_HOLE) != 0;
 134 +       return (ext4_es_type(es) & EXTENT_STATUS_HOLE) != 0;
 135 +}
 136 +
 137 +static inline void ext4_es_set_referenced(struct extent_status *es)
 138 +{
 139 +       es->es_pblk |= ((ext4_fsblk_t)EXTENT_STATUS_REFERENCED) << ES_SHIFT;
 140 +}
 141 +
 142 +static inline void ext4_es_clear_referenced(struct extent_status *es)
 143 +{
 144 +       es->es_pblk &= ~(((ext4_fsblk_t)EXTENT_STATUS_REFERENCED) << ES_SHIFT);
 145 +}
 146 +
 147 +static inline int ext4_es_is_referenced(struct extent_status *es)
 148 +{
 149 +       return (ext4_es_status(es) & EXTENT_STATUS_REFERENCED) != 0;
 150  }
 151
 152  static inline ext4_fsblk_t ext4_es_pblock(struct extent_status *es)
 153 --
 154 1.8.1.4
 155
 156