From mboxrd@z Thu Jan 1 00:00:00 1970 From: zwu.kernel@gmail.com Subject: [PATCH v3 04/13] VFS hot tracking: register one shrinker Date: Fri, 21 Jun 2013 20:17:13 +0800 Message-ID: <1371817042-8556-5-git-send-email-zwu.kernel@gmail.com> References: <1371817042-8556-1-git-send-email-zwu.kernel@gmail.com> Cc: viro@zeniv.linux.org.uk, sekharan@us.ibm.com, linuxram@us.ibm.com, david@fromorbit.com, chris.mason@fusionio.com, jbacik@fusionio.com, Zhi Yong Wu To: linux-fsdevel@vger.kernel.org Return-path: Received: from e34.co.us.ibm.com ([32.97.110.152]:44219 "EHLO e34.co.us.ibm.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1161045Ab3FUMSb (ORCPT ); Fri, 21 Jun 2013 08:18:31 -0400 Received: from /spool/local by e34.co.us.ibm.com with IBM ESMTP SMTP Gateway: Authorized Use Only! Violators will be prosecuted for from ; Fri, 21 Jun 2013 06:18:30 -0600 Received: from d03relay04.boulder.ibm.com (d03relay04.boulder.ibm.com [9.17.195.106]) by d03dlp03.boulder.ibm.com (Postfix) with ESMTP id 70BF619D8036 for ; Fri, 21 Jun 2013 06:18:19 -0600 (MDT) Received: from d03av01.boulder.ibm.com (d03av01.boulder.ibm.com [9.17.195.167]) by d03relay04.boulder.ibm.com (8.13.8/8.13.8/NCO v10.0) with ESMTP id r5LCISNr388462 for ; Fri, 21 Jun 2013 06:18:28 -0600 Received: from d03av01.boulder.ibm.com (loopback [127.0.0.1]) by d03av01.boulder.ibm.com (8.14.4/8.13.1/NCO v10.0 AVout) with ESMTP id r5LCIRpM019856 for ; Fri, 21 Jun 2013 06:18:28 -0600 In-Reply-To: <1371817042-8556-1-git-send-email-zwu.kernel@gmail.com> Sender: linux-fsdevel-owner@vger.kernel.org List-ID: From: Zhi Yong Wu Register a shrinker to control the amount of memory that is used in tracking hot regions. If we are throwing inodes out of memory due to memory pressure, we most definitely are going to need to reduce the amount of memory the tracking code is using, even if it means losing useful information That is, the shrinker accelerates the aging process. Signed-off-by: Chandra Seetharaman Signed-off-by: Zhi Yong Wu --- fs/hot_tracking.c | 76 ++++++++++++++++++++++++++++++++++++++++++-- include/linux/hot_tracking.h | 2 ++ 2 files changed, 76 insertions(+), 2 deletions(-) diff --git a/fs/hot_tracking.c b/fs/hot_tracking.c index 50c6820..3f3b656 100644 --- a/fs/hot_tracking.c +++ b/fs/hot_tracking.c @@ -103,8 +103,10 @@ static void hot_comm_item_unlink(struct hot_info *root, } spin_unlock(&root->m_lock); - if (flag) + if (flag) { + atomic_dec(&root->hot_map_nr); hot_comm_item_put(ci); + } if (ci->hot_freq_data.flags == TYPE_RANGE) { struct hot_range_item *hr = container_of(ci, @@ -464,8 +466,10 @@ static bool hot_map_update(struct hot_info *root, } spin_unlock(&root->m_lock); - if (!flag) + if (!flag) { + atomic_inc(&root->hot_map_nr); hot_comm_item_get(ci); + } spin_lock(&root->m_lock); if (test_bit(HOT_DELETING, &ci->delete_flag)) { @@ -523,6 +527,39 @@ static int hot_temp_cmp(void *priv, struct list_head *a, return 0; } +static void hot_item_evictor(struct hot_info *root, unsigned long work, + unsigned long (*work_get)(struct hot_info *root)) +{ + int i; + + if (work <= 0) + return; + + for (i = 0; i < MAP_SIZE; i++) { + struct hot_comm_item *ci; + unsigned long work_prev; + + rcu_read_lock(); + if (list_empty(&root->hot_map[TYPE_INODE][i])) { + rcu_read_unlock(); + continue; + } + + list_for_each_entry_rcu(ci, &root->hot_map[TYPE_INODE][i], + track_list) { + work_prev = work_get(root); + hot_comm_item_unlink(root, ci); + work -= (work_prev - work_get(root)); + if (work <= 0) + break; + } + rcu_read_unlock(); + + if (work <= 0) + break; + } +} + /* * Every sync period we update temperatures for * each hot inode item and hot range item for aging @@ -585,6 +622,34 @@ void __init hot_cache_init(void) } EXPORT_SYMBOL_GPL(hot_cache_init); +static inline unsigned long hot_nr_get(struct hot_info *root) +{ + return (unsigned long)atomic_read(&root->hot_map_nr); +} + +static void hot_prune_map(struct hot_info *root, unsigned long nr) +{ + hot_item_evictor(root, nr, hot_nr_get); +} + +/* The shrinker callback function */ +static int hot_track_prune(struct shrinker *shrink, + struct shrink_control *sc) +{ + struct hot_info *root = + container_of(shrink, struct hot_info, hot_shrink); + + if (sc->nr_to_scan == 0) + return atomic_read(&root->hot_map_nr) / 2; + + if (!(sc->gfp_mask & __GFP_FS)) + return -1; + + hot_prune_map(root, sc->nr_to_scan); + + return atomic_read(&root->hot_map_nr); +} + /* * Main function to update i/o access frequencies, and it will be called * from read/writepages() hooks, which are read_pages(), do_writepages(), @@ -649,6 +714,7 @@ static struct hot_info *hot_tree_init(struct super_block *sb) root->hot_inode_tree = RB_ROOT; spin_lock_init(&root->t_lock); spin_lock_init(&root->m_lock); + atomic_set(&root->hot_map_nr, 0); for (i = 0; i < MAP_SIZE; i++) { for (j = 0; j < MAX_TYPES; j++) @@ -669,6 +735,11 @@ static struct hot_info *hot_tree_init(struct super_block *sb) queue_delayed_work(root->update_wq, &root->update_work, msecs_to_jiffies(HOT_UPDATE_INTERVAL * MSEC_PER_SEC)); + /* Register a shrinker callback */ + root->hot_shrink.shrink = hot_track_prune; + root->hot_shrink.seeks = DEFAULT_SEEKS; + register_shrinker(&root->hot_shrink); + return root; } @@ -680,6 +751,7 @@ static void hot_tree_exit(struct hot_info *root) struct rb_node *node; struct hot_comm_item *ci; + unregister_shrinker(&root->hot_shrink); cancel_delayed_work_sync(&root->update_work); destroy_workqueue(root->update_wq); diff --git a/include/linux/hot_tracking.h b/include/linux/hot_tracking.h index 02a9521..8cb7526 100644 --- a/include/linux/hot_tracking.h +++ b/include/linux/hot_tracking.h @@ -90,8 +90,10 @@ struct hot_info { spinlock_t t_lock; /* protect above tree */ struct list_head hot_map[MAX_TYPES][MAP_SIZE]; /* map of inode temp */ spinlock_t m_lock; + atomic_t hot_map_nr; struct workqueue_struct *update_wq; struct delayed_work update_work; + struct shrinker hot_shrink; }; extern void __init hot_cache_init(void); -- 1.7.11.7