vfs: Use dlock list for SB's s_inodes list
v8 cover vfs: Use dlock list for SB's s_inodes list
v7->v8:
- Integrate the additional patches 8, 9 and 10 sent to fix issues in the original v7 patchset into patch 1 and adjust the other patches accordingly.
v6->v7:
- Fix outdated email address.
- Add a comment to patch 4 to explain allocation issue & fix a compilation problem with cpumask.
- Replace patch 6 with another one that adds an irqsafe mode argument in alloc_dlock_list_heads() instead of adding new APIs.
v5->v6:
- Rebased the patch to 4.14-rc3.
- Drop the fsnotify patch as it had been merged somehow.
- Add a new patch 5 with alternative way of selecting list by hashing instead of cpu #.
- Add a new patch 6 to proivde a set irq safe APIs to be used in interrupt context.
- Update the CPU to index mapping code.
v4->v5:
- Rebased the patch to 4.8-rc1 (changes to fs/fs-writeback.c was dropped).
- Use kcalloc() instead of percpu_alloc() to allocate the dlock list heads structure as suggested by Christoph Lameter.
- Replaced patch 5 by another one that made sibling CPUs use the same dlock list head thus reducing the number of list heads that needed to be maintained.
v3->v4:
- As suggested by Al, encapsulate the dlock list mechanism into the dlist_for_each_entry() and dlist_for_each_entry_safe() which are the equivalent of list_for_each_entry() and list_for_each_entry_safe() for regular linked list. That simplifies the changes in the call sites that perform dlock list iterations.
- Add a new patch to make the percpu head structure cacheline aligned to prevent cacheline contention from disrupting the performance of nearby percpu variables.
v2->v3:
- Remove the 2 persubnode API patches.
- Merge __percpu tag patch 2 into patch 1.
- As suggested by Tejun Heo, restructure the dlock_list_head data structure to hide the __percpu tag and rename some of the functions and structures.
- Move most of the code from dlock_list.h to dlock_list.c and export the symbols.
v1->v2:
- Add a set of simple per-subnode APIs that is between percpu and per-node in granularity.
- Make dlock list to use the per-subnode APIs so as to reduce the total number of separate linked list that needs to be managed and iterated.
- There is no change in patches 1-5.
This patchset provides new APIs for a set of distributed locked lists (one/CPU core) to minimize lock and cacheline contention. Insertion and deletion to the list will be cheap and relatively contention free. Lookup, on the other hand, may be a bit more costly as there are multiple lists to iterate. This is not really a problem for the replacement of superblock's inode list by dlock list included in the patchset as lookup isn't needed.
For use cases that need to do lookup, the dlock list can also be treated as a set of hashed lists that scales with the number of CPU cores in the system.
Both patches 5 and 6 are added to support other use cases like epoll nested callbacks, for example, which could use the dlock-list to reduce lock contention problem.
Patch 1 introduces the dlock list. The list heads are allocated by kcalloc() instead of percpu_alloc(). Each list head entry is cacheline aligned to minimize contention.
Patch 2 replaces the use of list_for_each_entry_safe() in evict_inodes() and invalidate_inodes() by list_for_each_entry().
Patch 3 modifies the superblock and inode structures to use the dlock list. The corresponding functions that reference those structures are modified.
Patch 4 makes the sibling CPUs use the same dlock list head to reduce the number of list heads that need to be iterated.
Patch 5 enables alternative use case of as a set of hashed lists.
Patch 6 provides an irq safe mode specified at dlock-list allocation time so that it can be used within interrupt context.
Jan Kara (1):
vfs: Remove unnecessary list_for_each_entry_safe() variants
Waiman Long (5):
lib/dlock-list: Distributed and lock-protected lists
vfs: Use dlock list for superblock's inode list lib/dlock-list: Make sibling CPUs share the same linked list lib/dlock-list: Enable faster lookup with hashing lib/dlock-list: Add an IRQ-safe mode to be used in interrupt handler
fs/block_dev.c | 9 +- fs/drop_caches.c | 9 +- fs/inode.c | 38 ++---- fs/notify/fsnotify.c | 9 +- fs/quota/dquot.c | 14 +- fs/super.c | 7 +- include/linux/dlock-list.h | 263 +++++++++++++++++++++++++++++++++++ include/linux/fs.h | 8 +- lib/Makefile | 2 +- lib/dlock-list.c | 333 +++++++++++++++++++++++++++++++++++++++++++++ 10 files changed, 638 insertions(+), 54 deletions(-) create mode 100644 include/linux/dlock-list.h create mode 100644 lib/dlock-list.c
Signature · 1 line
1.8.3.1
PATCH v8 1/6 lib/dlock-list: Distributed and lock-protected lists
Linked list is used everywhere in the Linux kernel. However, if many threads are trying to add or delete entries into the same linked list, it can create a performance bottleneck.
This patch introduces a new list APIs that provide a set of distributed lists (one per CPU), each of which is protected by its own spinlock. To the callers, however, the set of lists acts like a single consolidated list. This allows list entries insertion and deletion operations to happen in parallel instead of being serialized with a global list and lock.
List entry insertion is strictly per cpu. List deletion, however, can happen in a cpu other than the one that did the insertion. So we still need lock to protect the list. Because of that, there may still be a small amount of contention when deletion is being done.
A new header file include/linux/dlock-list.h will be added with the associated dlock_list_head and dlock_list_node structures. The following functions are provided to manage the per-cpu list:
1. int alloc_dlock_list_heads(struct dlock_list_heads *dlist)
2. void free_dlock_list_heads(struct dlock_list_heads *dlist)
3. void dlock_list_add(struct dlock_list_node *node, struct dlock_list_heads *dlist)
4. void dlock_list_del(struct dlock_list *node)
Iteration of all the list entries within a dlock list array is done by calling either the dlist_for_each_entry() or dlist_for_each_entry_safe() macros. They correspond to the list_for_each_entry() and list_for_each_entry_safe() macros respectively. The iteration states are keep in a dlock_list_iter structure that is passed to the iteration macros.
--- include/linux/dlock-list.h | 242 +++++++++++++++++++++++++++++++++++++++++++++ lib/Makefile | 2 +- lib/dlock-list.c | 234 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 477 insertions(+), 1 deletion(-) create mode 100644 include/linux/dlock-list.h create mode 100644 lib/dlock-list.c
include/linux/dlock-list.h new file +242 -0
@@ -0,0 +1,242 @@ +/* +* Distributed and locked list +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation; either version 2 of the License, or +* (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* (C) Copyright 2016 Hewlett-Packard Enterprise Development LP +* (C) Copyright 2017 Red Hat, Inc. +* +* Authors: Waiman Long <[email protected]> +*/ +#ifndef __LINUX_DLOCK_LIST_H +#define __LINUX_DLOCK_LIST_H + +#include <linux/spinlock.h> +#include <linux/list.h> + +/* +* include/linux/dlock-list.h +* +* The dlock_list_head structure contains the spinlock. It is cacheline +* aligned to reduce contention among different CPUs. The other +* dlock_list_node structures contains a pointer to the head entry instead. +*/ +struct dlock_list_head { +struct list_head list; +spinlock_t lock; +}____cacheline_aligned_in_smp ; + +struct dlock_list_heads { +struct dlock_list_head *heads; +}; + +/* +* dlock list node data structure +*/ +struct dlock_list_node { +struct list_head list; +struct dlock_list_head *head; +}; + +/* +* dlock list iteration state +* +* This is an opaque data structure that may change. Users of this structure +* should not access the structure members directly other than using the +* helper functions and macros provided in this header file. +*/ +struct dlock_list_iter { +int index; +struct dlock_list_head *head, *entry; +}; + +#define DLOCK_LIST_ITER_INIT (dlist) \ + { \ + .index = -1, \ + .head = (dlist)->heads, \ + } + +#define DEFINE_DLOCK_LIST_ITER (s, heads) \ + struct dlock_list_iter s = DLOCK_LIST_ITER_INIT(heads) + +static inline void init_dlock_list_iter (struct dlock_list_iter *iter, +struct dlock_list_heads *heads) +{ + *iter = (struct dlock_list_iter )DLOCK_LIST_ITER_INIT (heads); +} + +#define DLOCK_LIST_NODE_INIT (name) \ + { \ + .list = LIST_HEAD_INIT(name) \ + } + +static inline void init_dlock_list_node (struct dlock_list_node *node) +{ + *node = (struct dlock_list_node )DLOCK_LIST_NODE_INIT (node->list); +} + +/** +* dlock_list_unlock - unlock the spinlock that protects the current list +* @iter: Pointer to the dlock list iterator structure +*/ +static inline void dlock_list_unlock (struct dlock_list_iter *iter) +{ +spin_unlock (&iter->entry->lock); +} + +/** +* dlock_list_relock - lock the spinlock that protects the current list +* @iter: Pointer to the dlock list iterator structure +*/ +static inline void dlock_list_relock (struct dlock_list_iter *iter) +{ +spin_lock (&iter->entry->lock); +} + +/* +* Allocation and freeing of dlock list +*/ +extern int __alloc_dlock_list_heads (struct dlock_list_heads *dlist, +struct lock_class_key *key); +extern void free_dlock_list_heads (struct dlock_list_heads *dlist); + +/** +* alloc_dlock_list_head - Initialize and allocate the list of head entries. +* @dlist : Pointer to the dlock_list_heads structure to be initialized +* Return : 0 if successful, -ENOMEM if memory allocation error +*/ +#define alloc_dlock_list_heads (dlist) \ +({ \ + static struct lock_class_key _key; \ + __alloc_dlock_list_heads(dlist, &_key); \ +}) + +/* +* Check if a dlock list is empty or not. +*/ +extern bool dlock_lists_empty (struct dlock_list_heads *dlist); + +/* +* The dlock list addition and deletion functions here are not irq-safe. +* Special irq-safe variants will have to be added if we need them. +*/ +extern void dlock_lists_add (struct dlock_list_node *node, +struct dlock_list_heads *dlist); +extern void dlock_lists_del (struct dlock_list_node *node); + +/* +* Find the first entry of the next available list. +*/ +extern struct dlock_list_node * +__dlock_list_next_list (struct dlock_list_iter *iter); + +/** +* __dlock_list_next_entry - Iterate to the next entry of the dlock list +* @curr : Pointer to the current dlock_list_node structure +* @iter : Pointer to the dlock list iterator structure +* Return: Pointer to the next entry or NULL if all the entries are iterated +* +* The iterator has to be properly initialized before calling this function. +*/ +static inline struct dlock_list_node * +__dlock_list_next_entry (struct dlock_list_node *curr, +struct dlock_list_iter *iter) +{ +/* +* Find next entry +*/ +if (curr) + curr =list_next_entry (curr, list); + +if (!curr || (&curr->list == &iter->entry->list)) { +/* +* The current list has been exhausted, try the next available +* list. +*/ + curr =__dlock_list_next_list (iter); + } + +return curr;/* Continue the iteration */ +} + +/** +* _dlock_list_next_list_entry - get first element from next list in iterator +* @iter : The dlock list iterator. +* @pos : A variable of the struct that is embedded in. +* @member: The name of the dlock_list_node within the struct. +* Return : Pointer to first entry or NULL if all the lists are iterated. +*/ +#define _dlock_list_next_list_entry (iter, pos, member) \ + ({ \ + struct dlock_list_node *_n; \ + _n = __dlock_list_next_entry(NULL, iter); \ + _n ? list_entry(_n, typeof(*pos), member) : NULL; \ + }) + +/** +* _dlock_list_next_entry - iterate to the next entry of the list +* @pos : The type * to cursor +* @iter : The dlock list iterator. +* @member: The name of the dlock_list_node within the struct. +* Return : Pointer to the next entry or NULL if all the entries are iterated. +* +* Note that pos can't be NULL. +*/ +#define _dlock_list_next_entry (pos, iter, member) \ + ({ \ + struct dlock_list_node *_n; \ + _n = __dlock_list_next_entry(&(pos)->member, iter); \ + _n ? list_entry(_n, typeof(*(pos)), member) : NULL; \ + }) + +/** +* dlist_for_each_entry - iterate over the dlock list +* @pos : Type * to use as a loop cursor +* @iter : The dlock list iterator +* @member: The name of the dlock_list_node within the struct +* +* This iteration macro isn't safe with respect to list entry removal, but +* it can correctly iterate newly added entries right after the current one. +* This iteration function is designed to be used in a while loop. +*/ +#define dlist_for_each_entry (pos, iter, member) \ + for (pos = _dlock_list_next_list_entry(iter, pos, member); \ + pos != NULL; \ + pos = _dlock_list_next_entry(pos, iter, member)) + +/** +* dlist_for_each_entry_safe - iterate over the dlock list & safe over removal +* @pos : Type * to use as a loop cursor +* @n : Another type * to use as temporary storage +* @iter : The dlock list iterator +* @member: The name of the dlock_list_node within the struct +* +* This iteration macro is safe with respect to list entry removal. +* However, it cannot correctly iterate newly added entries right after the +* current one. +* +* The call to __dlock_list_next_list() is deferred until the next entry +* is being iterated to avoid use-after-unlock problem. +*/ +#define dlist_for_each_entry_safe (pos, n, iter, member) \ + for (pos = NULL; \ + ({ \ + if (!pos || \ + (&(pos)->member.list == &(iter)->entry->list)) \ + pos = _dlock_list_next_list_entry(iter, pos, \ + member); \ + if (pos) \ + n = list_next_entry(pos, member.list); \ + pos; \ + }); \ + pos = n) + +#endif /* __LINUX_DLOCK_LIST_H */
lib/Makefile +1 -1
@@ -38,7 +38,7 @@ obj-y += bcd.o div64.o sort.o parser.o debug_locks.o random32.o \ gcd.o lcm.o list_sort.o uuid.o flex_array.o iov_iter.o clz_ctz.o \ bsearch.o find_bit.o llist.o memweight.o kfifo.o \ percpu-refcount.o percpu_ida.o rhashtable.o reciprocal_div.o \ - once.o refcount.o usercopy.o errseq.o + once.o refcount.o usercopy.o errseq.o dlock-list.o obj-y += string_helpers.o obj-$(CONFIG_TEST_STRING_HELPERS) += test-string_helpers.o obj-y += hexdump.o
lib/dlock-list.c new file +234 -0
234 lines not on this page · raw message
Signature · 1 line
1.8.3.1
Re: [PATCH v8 1/6] lib/dlock-list: Distributed and lock-protected lists
lib/dlock-list.c line 166
Quoted 7 lines · Waiman Long
lib/dlock-list.c new file +7
-0+void dlock_lists_del (struct dlock_list_node *node) +{ +struct dlock_list_head *head; +bool retry; + + do { + head = READ_ONCE(node->head);
Boqun had previously pointed this out; you need to WRITE_ONCE() node->head too.
Thanks,
Davidlohr
Re: [PATCH v8 1/6] lib/dlock-list: Distributed and lock-protected lists
Quoted 12 lines · Davidlohr Bueso
lib/dlock-list.c line 166
Quoted 7 lines · Waiman Long
lib/dlock-list.c new file +7
-0+void dlock_lists_del (struct dlock_list_node *node) +{ +struct dlock_list_head *head; +bool retry; + + do { + head = READ_ONCE(node->head);Boqun had previously pointed this out; you need to
WRITE_ONCE()node->headtoo.
Right, I will get that into the next version of the patch.
Cheers,
Longman
Re: [PATCH v8 1/6] lib/dlock-list: Distributed and lock-protected lists
In reply to Waiman LongQuoted 9 lines · Waiman Long
+/**
+ *dlock_lists_empty- Check if all the dlock lists are empty
+ * @dlist: Pointer to thedlock_list_headsstructure
+ * Return: true if list is empty, false otherwise.
+ *
+ * This can be a pretty expensive function call. If this function is required
+ * in a performance critical path, we may have to maintain a global count
+ * of the list entries in the globaldlock_list_headsstructure instead.
+ */
I vote for doing this in the original version. How about the following?
Review
Quoted 10 lines
(quoted diff) +10
-0+bool dlock_lists_empty(struct dlock_list_heads *dlist) +{ + int idx; + + for (idx = 0; idx < nr_cpu_ids; idx++) + if (!list_empty(&dlist->heads[idx].list)) + return false; + return true; +} +EXPORT_SYMBOL(dlock_lists_empty);
----------8<-----------------------------------------------
From: Davidlohr Bueso <[email protected]>
Subject: [PATCH] lib/dlock-list: Scale dlock_lists_empty()
Instead of the current O(N) implementation; at the cost of adding an atomic counter. We also need to add a heads pointer to the node structure such that we can unaccount a thread doing list_del().
---include/linux/dlock-list.h | 2 ++lib/dlock-list.c | 40 ++++++++++++++++++++++++++++------------
2 files changed, 30 insertions(+), 12 deletions(-)
include/linux/dlock-list.h +0 -0
@@ -36,6 +36,7 @@ struct dlock_list_head {
struct dlock_list_heads {
struct dlock_list_head *heads;+ atomic_t waiters;
};
/*
@@ -44,6 +45,7 @@ struct dlock_list_heads {
struct dlock_list_node {
struct list_head list;
struct dlock_list_head *head;+ struct dlock_list_heads *heads;
};
/*
lib/dlock-list.c +0 -0
@@ -124,6 +124,8 @@ int __alloc_dlock_list_heads(struct dlock_list_heads *dlist,
head->lock = __SPIN_LOCK_UNLOCKED(&head->lock);
lockdep_set_class(&head->lock, key);
}
+
+ atomic_set(&dlist->waiters, 0);
return 0;
}
EXPORT_SYMBOL(__alloc_dlock_list_heads);
@@ -139,29 +141,23 @@ void free_dlock_list_heads(struct dlock_list_heads *dlist)
{
kfree(dlist->heads);
dlist->heads = NULL;+ atomic_set(&dlist->waiters, 0);
}EXPORT_SYMBOL(free_dlock_list_heads);
/**
* dlock_lists_empty - Check if all the dlock lists are empty
* @dlist: Pointer to the dlock_list_heads structure
- * Return: true if list is empty, false otherwise.
*
- * This can be a pretty expensive function call. If this function is required
- * in a performance critical path, we may have to maintain a global count
- * of the list entries in the global dlock_list_heads structure instead.
+ * Return: true if all dlock lists are empty, false otherwise. */
bool dlock_lists_empty(struct dlock_list_heads *dlist)
{
- int idx;
-
/* Shouldn't be called before nr_dlock_lists is initialized */ WARN_ON_ONCE(!nr_dlock_lists);
- for (idx = 0; idx < nr_dlock_lists; idx++)
- if (!list_empty(&dlist->heads[idx].list))
- return false;
- return true;
+ smp_mb__before_atomic();
+ return !atomic_read(&dlist->waiters);
}EXPORT_SYMBOL(dlock_lists_empty);
@@ -179,10 +175,30 @@ void dlock_lists_add(struct dlock_list_node *node,
struct dlock_list_head *head = &dlist->heads[this_cpu_read(cpu2idx)]; /*
+ * Serialize dlist->waiters such that a 0->1 transition is not missed,
+ * by another thread checking if any of the dlock lists are used.
+ *
+ * CPU0 CPU1
+ * dlock_list_add() dlock_lists_empty()
+ * [S] atomic_inc(waiters);
+ * smp_mb__after_atomic();
+ * smp_mb__before_atomic();
+ * [L] atomic_read(waiters)
+ * list_add()
+ *
+ * Bump the waiters counter _before_ taking the head->lock such that we
+ * don't miss a thread adding itself to a list while spinning for the
+ * lock.
+ */
+ atomic_inc(&dlist->waiters);
+ smp_mb__after_atomic();
+
+ /*
* There is no need to disable preemption */ spin_lock(&head->lock); node->head = head; + node->heads = dlist; list_add(&node->list, &head->list); spin_unlock(&head->lock); }
@@ -199,8 +215,7 @@ EXPORT_SYMBOL(dlock_lists_add);
* a bug.
*/
void dlock_lists_del(struct dlock_list_node *node) -{
- struct dlock_list_head *head;
+{ struct dlock_list_head *head;
bool retry;
do {
@@ -214,6 +229,7 @@ void dlock_lists_del(struct dlock_list_node *node)
list_del_init(&node->list);
node->head = NULL;
retry = false;
+ atomic_dec(&node->heads->waiters);
} else {
/*
* The lock has somehow changed. Retry again if it isSignature · 1 line
2.13.6
Re: [PATCH v8 1/6] lib/dlock-list: Distributed and lock-protected lists
Quoted 31 lines · Davidlohr Bueso
Quoted 11 lines · Waiman Long
+/**
+ *dlock_lists_empty- Check if all the dlock lists are empty
+ * @dlist: Pointer to thedlock_list_headsstructure
+ * Return: true if list is empty, false otherwise.
+ * + * This can be a pretty expensive function call. If
this function is required
+ * in a performance critical path, we may have to maintain a global count
+ * of the list entries in the globaldlock_list_headsstructure instead.
+ */I vote for doing this in the original version. How about the following?
Review
Quoted 10 lines
(quoted diff) +10
-0+bool dlock_lists_empty(struct dlock_list_heads *dlist) +{ + int idx; + + for (idx = 0; idx < nr_cpu_ids; idx++) + if (!list_empty(&dlist->heads[idx].list)) + return false; + return true; +} +EXPORT_SYMBOL(dlock_lists_empty);----------8<-----------------------------------------------
From: Davidlohr Bueso <[email protected]>
Subject: [PATCH]lib/dlock-list: Scaledlock_lists_empty()
Quoted 5 lines
Instead of the current O(N) implementation; at the cost of adding an atomic counter. We also need to add a heads pointer to the node structure such that we can unaccount a thread doing
list_del().
The counter will then become the single contention point for all concurrent updates to the dlock-list. So it will have a big impact on performance. On the other hand, instead of being a counter of # of items, we can make that a counter of # of non-empty lists. So its value will only be changed when a list go from empty to non-empty and vice versa. That will greatly reduce the number of updates to that counter.
Quoted 19 lines
Signed-off-by Davidlohr Bueso <[email protected]>---
include/linux/dlock-list.h| 2 ++lib/dlock-list.c| 40 ++++++++++++++++++++++++++++------------2 files changed, 30 insertions(+), 12 deletions(-)include/linux/dlock-list.h +1
-0@@ -36,6 +36,7 @@ struct dlock_list_head {struct dlock_list_heads {struct dlock_list_head *heads; +atomic_t waiters; };/*
include/linux/dlock-list.h struct dlock_list_heads { · line 50
Quoted 6 lines
include/linux/dlock-list.h +1
-0@@ -44,6 +45,7 @@ struct dlock_list_heads {struct dlock_list_node {struct list_head list;struct dlock_list_head *head; +struct dlock_list_heads *heads; };
I don't want to add a new data item into dlock_list_node as there can be thousands or even of them in the system. Instead, I prefer increasing the size of dlock_list_head which only have a limited number of them and they have unused space because they are cacheline aligned.
Cheers,
Longman
Re: [PATCH v8 1/6] lib/dlock-list: Distributed and lock-protected lists
Quoted 31 lines · Waiman Long
Quoted 5 lines
Instead of the current O(N) implementation; at the cost of adding an atomic counter. We also need to add a heads pointer to the node structure such that we can unaccount a thread doing
list_del().The counter will then become the single contention point for all concurrent updates to the dlock-list. So it will have a big impact on performance. On the other hand, instead of being a counter of # of items, we can make that a counter of # of non-empty lists. So its value will only be changed when a list go from empty to non-empty and vice versa. That will greatly reduce the number of updates to that counter.
Quoted 17 lines
Signed-off-by Davidlohr Bueso <[email protected]>---
include/linux/dlock-list.h| 2 ++lib/dlock-list.c| 40 ++++++++++++++++++++++++++++------------2 files changed, 30 insertions(+), 12 deletions(-)include/linux/dlock-list.h +1
-0@@ -36,6 +36,7 @@ struct dlock_list_head {struct dlock_list_heads {struct dlock_list_head *heads; +atomic_t waiters; };
Quoted 13 lines
include/linux/dlock-list.h struct dlock_list_heads { · line 50
Quoted 8 lines
include/linux/dlock-list.h +1
-0/* @@ -44,6 +45,7 @@ struct dlock_list_heads {struct dlock_list_node {struct list_head list;struct dlock_list_head *head; +struct dlock_list_heads *heads; };I don't want to add a new data item into
dlock_list_nodeas there can be thousands or even of them in the system. Instead, I prefer increasing the size ofdlock_list_headwhich only have a limited number of them and they have unused space because they are cacheline aligned.
Both are good points. Thanks.
----8<--------------------------------------------------------
Subject: [PATCH] [PATCH v2] lib/dlock-list: Scale dlock_lists_empty()
Instead of the current O(N) implementation, at the cost of adding an atomic counter, we can convert the call to an atomic_read(). The counter only serves for accounting empty to non-empty transitions, and vice versa; therefore only modified twice for each of the lists, during the lifetime of the dlock -- thus 2*nr_dlock_lists.
In addition, to be able to unaccount a list_del(), we add a dlist pointer to each head, thus minimizing the overall memory footprint.
---include/linux/dlock-list.h | 2 ++lib/dlock-list.c | 56 +++++++++++++++++++++++++++++++++++-----------
2 files changed, 45 insertions(+), 13 deletions(-)
include/linux/dlock-list.h +0 -0
@@ -32,10 +32,12 @@
struct dlock_list_head {
struct list_head list;
spinlock_t lock;+ struct dlock_list_heads *dlist;
} ____cacheline_aligned_in_smp;
struct dlock_list_heads {
struct dlock_list_head *heads;+ atomic_t waiters;
};
/*
lib/dlock-list.c +0 -0
@@ -122,8 +122,11 @@ int __alloc_dlock_list_heads(struct dlock_list_heads *dlist,
INIT_LIST_HEAD(&head->list);
head->lock = __SPIN_LOCK_UNLOCKED(&head->lock);
+ head->dlist = dlist;
lockdep_set_class(&head->lock, key);
}
+
+ atomic_set(&dlist->waiters, 0);
return 0;
}
EXPORT_SYMBOL(__alloc_dlock_list_heads);
@@ -138,30 +141,36 @@ EXPORT_SYMBOL(__alloc_dlock_list_heads);
void free_dlock_list_heads(struct dlock_list_heads *dlist)
{
kfree(dlist->heads);- dlist->heads = NULL;
+ atomic_set(&dlist->waiters, 0);
}EXPORT_SYMBOL(free_dlock_list_heads);
/**
* dlock_lists_empty - Check if all the dlock lists are empty
* @dlist: Pointer to the dlock_list_heads structure
- * Return: true if list is empty, false otherwise.
*
- * This can be a pretty expensive function call. If this function is required
- * in a performance critical path, we may have to maintain a global count
- * of the list entries in the global dlock_list_heads structure instead.
+ * Return: true if all dlock lists are empty, false otherwise. */
bool dlock_lists_empty(struct dlock_list_heads *dlist)
{
- int idx;
-
/* Shouldn't be called before nr_dlock_lists is initialized */ WARN_ON_ONCE(!nr_dlock_lists);
- for (idx = 0; idx < nr_dlock_lists; idx++)
- if (!list_empty(&dlist->heads[idx].list))
- return false;
- return true;
+ /*
+ * Serialize dlist->waiters such that a 0->1 transition is not missed
+ * by another thread checking if any of the dlock lists are used.
+ *
+ * CPU0 CPU1
+ * dlock_list_add() dlock_lists_empty()
+ * [S] atomic_inc(waiters);
+ * smp_mb__after_atomic();
+ * smp_mb__before_atomic();
+ * [L] atomic_read(waiters)
+ * list_add()
+ *
+ */
+ smp_mb__before_atomic();
+ return !atomic_read(&dlist->waiters);
}EXPORT_SYMBOL(dlock_lists_empty);
@@ -179,6 +188,16 @@ void dlock_lists_add(struct dlock_list_node *node,
struct dlock_list_head *head = &dlist->heads[this_cpu_read(cpu2idx)]; /*
+ * Bump the waiters counter _before_ taking the head->lock
+ * such that we don't miss a thread adding itself to a list
+ * while spinning for the lock.
+ */
+ if (list_empty_careful(&head->list)) {
+ atomic_inc(&dlist->waiters);
+ smp_mb__after_atomic();
+ }
+
+ /*
* There is no need to disable preemption */ spin_lock(&head->lock);
@@ -199,8 +218,7 @@ EXPORT_SYMBOL(dlock_lists_add);
* a bug.
*/
void dlock_lists_del(struct dlock_list_node *node) -{
- struct dlock_list_head *head;
+{ struct dlock_list_head *head;
bool retry;
do {
@@ -212,6 +230,18 @@ void dlock_lists_del(struct dlock_list_node *node)
spin_lock(&head->lock);
if (likely(head == node->head)) {
list_del_init(&node->list);+ /*
+ * We still hold the head->lock, a normal list_empty()
+ * check will do.
+ */
+ if (list_empty(&head->list)) {
+ struct dlock_list_heads *dlist;
+ dlist = node->head->dlist;
+
+ atomic_dec(&dlist->waiters);
+ smp_mb__after_atomic();
+ }
+
node->head = NULL;
retry = false;
} else {Signature · 1 line
2.13.6
PATCH v3 1/1 lib/dlock-list: Scale dlock_lists_empty()
Instead of the current O(N) implementation, at the cost of adding an atomic counter, we can convert the call to an atomic_read(). The counter only serves for accounting empty to non-empty transitions, and vice versa; therefore only modified twice for each of the lists during the lifetime of the dlock (while used).
In addition, to be able to unaccount a list_del(), we add a dlist pointer to each head, thus minimizing the overall memory footprint.
---
Changes from v2: Removed some bogus lines and an overoptimistic
changelog.
include/linux/dlock-list.h | 2 ++lib/dlock-list.c | 52 +++++++++++++++++++++++++++++++++++++---------
2 files changed, 44 insertions(+), 10 deletions(-)
include/linux/dlock-list.h +0 -0
@@ -32,10 +32,12 @@
struct dlock_list_head {
struct list_head list;
spinlock_t lock;+ struct dlock_list_heads *dlist;
} ____cacheline_aligned_in_smp;
struct dlock_list_heads {
struct dlock_list_head *heads;+ atomic_t waiters;
};
/*
lib/dlock-list.c +0 -0
@@ -122,8 +122,11 @@ int __alloc_dlock_list_heads(struct dlock_list_heads *dlist,
INIT_LIST_HEAD(&head->list);
head->lock = __SPIN_LOCK_UNLOCKED(&head->lock);
+ head->dlist = dlist;
lockdep_set_class(&head->lock, key);
}
+
+ atomic_set(&dlist->waiters, 0);
return 0;
}
EXPORT_SYMBOL(__alloc_dlock_list_heads);
@@ -139,29 +142,36 @@ void free_dlock_list_heads(struct dlock_list_heads *dlist)
{
kfree(dlist->heads);
dlist->heads = NULL;+ atomic_set(&dlist->waiters, 0);
}EXPORT_SYMBOL(free_dlock_list_heads);
/**
* dlock_lists_empty - Check if all the dlock lists are empty
* @dlist: Pointer to the dlock_list_heads structure
- * Return: true if list is empty, false otherwise.
*
- * This can be a pretty expensive function call. If this function is required
- * in a performance critical path, we may have to maintain a global count
- * of the list entries in the global dlock_list_heads structure instead.
+ * Return: true if all dlock lists are empty, false otherwise. */
bool dlock_lists_empty(struct dlock_list_heads *dlist)
{
- int idx;
-
/* Shouldn't be called before nr_dlock_lists is initialized */ WARN_ON_ONCE(!nr_dlock_lists);
- for (idx = 0; idx < nr_dlock_lists; idx++)
- if (!list_empty(&dlist->heads[idx].list))
- return false;
- return true;
+ /*
+ * Serialize dlist->waiters such that a 0->1 transition is not missed
+ * by another thread checking if any of the dlock lists are used.
+ *
+ * CPU0 CPU1
+ * dlock_list_add() dlock_lists_empty()
+ * [S] atomic_inc(waiters);
+ * smp_mb__after_atomic();
+ * smp_mb__before_atomic();
+ * [L] atomic_read(waiters)
+ * list_add()
+ *
+ */
+ smp_mb__before_atomic();
+ return !atomic_read(&dlist->waiters);
}EXPORT_SYMBOL(dlock_lists_empty);
@@ -179,6 +189,16 @@ void dlock_lists_add(struct dlock_list_node *node,
struct dlock_list_head *head = &dlist->heads[this_cpu_read(cpu2idx)]; /*
+ * Bump the waiters counter _before_ taking the head->lock
+ * such that we don't miss a thread adding itself to a list
+ * while spinning for the lock.
+ */
+ if (list_empty_careful(&head->list)) {
+ atomic_inc(&dlist->waiters);
+ smp_mb__after_atomic();
+ }
+
+ /*
* There is no need to disable preemption
*/
spin_lock(&head->lock);
@@ -212,6 +232,18 @@ void dlock_lists_del(struct dlock_list_node *node)
spin_lock(&head->lock);
if (likely(head == node->head)) {
list_del_init(&node->list);+ /*
+ * We still hold the head->lock, a normal list_empty()
+ * check will do.
+ */
+ if (list_empty(&head->list)) {
+ struct dlock_list_heads *dlist;
+ dlist = node->head->dlist;
+
+ atomic_dec(&dlist->waiters);
+ smp_mb__after_atomic();
+ }
+
node->head = NULL;
retry = false;
} else {Signature · 1 line
2.13.6
Re: [PATCH v3] lib/dlock-list: Scale dlock_lists_empty()
Quoted 27 lines · Davidlohr Bueso
Instead of the current O(N) implementation, at the cost of adding an atomic counter, we can convert the call to an
atomic_read(). The counter only serves for accounting empty to non-empty transitions, and vice versa; therefore only modified twice for each of the lists during the lifetime of the dlock (while used).In addition, to be able to unaccount a
list_del(), we add a dlist pointer to each head, thus minimizing the overall memory footprint.Signed-off-by Davidlohr Bueso <[email protected]>---
Changes from v2: Removed some bogus lines and an overoptimistic
changelog.
include/linux/dlock-list.h| 2 ++lib/dlock-list.c| 52
+++++++++++++++++++++++++++++++++++++---------2 files changed, 44 insertions(+), 10 deletions(-)include/linux/dlock-list.h +0
-0
include/linux/dlock-list.h line 40
Quoted 9 lines
include/linux/dlock-list.h +2
-0@@ -32,10 +32,12 @@struct dlock_list_head {struct list_head list;spinlock_t lock; +struct dlock_list_heads *dlist; }____cacheline_aligned_in_smp ;struct dlock_list_heads {struct dlock_list_head *heads; +atomic_t waiters;
We are tracking number of non-empty lists here. So I think we need a better name and maybe some documentation of what it is.
Quoted 73 lines
include/linux/dlock-list.h +0
-0};/* lib/dlock-list.c +3
-0@@ -122,8 +122,11 @@ int __alloc_dlock_list_heads(struct dlock_list_heads *dlist,INIT_LIST_HEAD (&head->list); head->lock =__SPIN_LOCK_UNLOCKED (&head->lock); + head->dlist = dlist;lockdep_set_class (&head->lock, key); } + +atomic_set (&dlist->waiters,0 );return 0 ; }
EXPORT_SYMBOL(__alloc_dlock_list_heads);lib/dlock-list.c +1
-2@@ -139,29 +142,36 @@ void free_dlock_list_heads(struct dlock_list_heads *dlist) {kfree (dlist->heads); dlist->heads =NULL ; +atomic_set (&dlist->waiters,0 ); }EXPORT_SYMBOL (free_dlock_list_heads);/** * dlock_lists_empty - Check if all the dlock lists are empty * @dlist: Pointer to the dlock_list_heads structure -* Return: true if list is empty, false otherwise. * -* This can be a pretty expensive function call. If this function is required
- * in a performance critical path, we may have to maintain a global count
- * of the list entries in the globaldlock_list_headsstructure instead.
+ * Return: true if all dlock lists are empty, false otherwise. */
booldlock_lists_empty(struct dlock_list_heads *dlist)
{lib/dlock-list.c +2
-6-int idx; -/* Shouldn't be called before nr_dlock_lists is initialized */ WARN_ON_ONCE (!nr_dlock_lists); -for (idx =0 ; idx < nr_dlock_lists; idx++) -if (!list_empty (&dlist->heads[idx].list)) -return false; -return true; +/* +* Serialize dlist->waiters such that a 0->1 transition is not missed
lib/dlock-list.c +13
-0+* by another thread checking if any of the dlock lists are used. +* +* CPU0 CPU1 +* dlock_list_add() dlock_lists_empty() +* [S] atomic_inc(waiters); +* smp_mb__after_atomic(); +* smp_mb__before_atomic(); +* [L] atomic_read(waiters) +* list_add() +* +*/ +smp_mb__before_atomic (); +return !atomic_read (&dlist->waiters);}
EXPORT_SYMBOL(dlock_lists_empty);lib/dlock-list.c +0
-0@@ -179,6 +189,16 @@ void dlock_lists_add(struct dlock_list_node *node,struct dlock_list_head *head = &dlist->heads[this_cpu_read (cpu2idx)];
lib/dlock-list.c void dlock_lists_add(struct dlock_list_node *node, · line 199
Quoted 10 lines
lib/dlock-list.c +8
-0/* +* Bump the waiters counter _before_ taking the head->lock +* such that we don't miss a thread adding itself to a list +* while spinning for the lock. +*/ +if (list_empty_careful (&head->list)) { +atomic_inc (&dlist->waiters); +smp_mb__after_atomic (); + }
That is racy. You will need to remember that you have opportunistically incremented the count. After acquiring the spinlock, the code will have to decrement it if the list is no longer empty. You will also have to increment it after lock if the list is empty now, but not previously.
Quoted 10 lines
lib/dlock-list.c +2
-0+ +/* * There is no need to disable preemption */ spin_lock (&head->lock);@@ -212,6 +232,18 @@ void dlock_lists_del(struct dlock_list_node *node)spin_lock (&head->lock);if (likely (head == node->head)) {list_del_init (&node->list);
lib/dlock-list.c void dlock_lists_del(struct dlock_list_node *node) · line 244
Quoted 10 lines
lib/dlock-list.c +10
-0+/* +* We still hold the head->lock, a normal list_empty() +* check will do. +*/ +if (list_empty (&head->list)) { +struct dlock_list_heads *dlist; + dlist = node->head->dlist; + +atomic_dec (&dlist->waiters); +smp_mb__after_atomic ();
Do you need that while the code will do a spin_unlock soon?
Cheers,
Longman
PATCH v4 1/1 lib/dlock-list: Scale dlock_lists_empty()
Instead of the current O(N) implementation, at the cost of adding an atomic counter, we can convert the call to an atomic_read(). The counter only serves for accounting empty to non-empty transitions, and vice versa; therefore only modified twice for each of the lists during the lifetime of the dlock (while used).
In addition, to be able to unaccount a list_del(), we add a dlist pointer to each head, thus minimizing the overall memory footprint.
---
Changes from v3:
- s/waiters/used_lists, more doc around the counter.
- fixed racy scenario when the list empty/non-empty condition changes after taking the lock.
- sprinkled unlikely() around all checks, these are only corner cases in the lifetime of the lock.
include/linux/dlock-list.h | 8 ++++++lib/dlock-list.c | 67 +++++++++++++++++++++++++++++++++++++++-------
2 files changed, 65 insertions(+), 10 deletions(-)
include/linux/dlock-list.h +0 -0
@@ -32,10 +32,18 @@
struct dlock_list_head {
struct list_head list;
spinlock_t lock;+ struct dlock_list_heads *dlist;
} ____cacheline_aligned_in_smp;
+/*
+ * This is the main dlist data structure, with the array of heads
+ * and a counter that atomically tracks if any of the lists are
+ * being used. That is, empty to non-empty (and vice versa)
+ * head->list transitions.
+ */
struct dlock_list_heads {
struct dlock_list_head *heads;+ atomic_t used_lists;
};
/*
lib/dlock-list.c +0 -0
@@ -122,8 +122,11 @@ int __alloc_dlock_list_heads(struct dlock_list_heads *dlist,
INIT_LIST_HEAD(&head->list);
head->lock = __SPIN_LOCK_UNLOCKED(&head->lock);
+ head->dlist = dlist;
lockdep_set_class(&head->lock, key);
}
+
+ atomic_set(&dlist->used_lists, 0);
return 0;
}
EXPORT_SYMBOL(__alloc_dlock_list_heads);
@@ -139,29 +142,36 @@ void free_dlock_list_heads(struct dlock_list_heads *dlist)
{
kfree(dlist->heads);
dlist->heads = NULL;+ atomic_set(&dlist->used_lists, 0);
}EXPORT_SYMBOL(free_dlock_list_heads);
/**
* dlock_lists_empty - Check if all the dlock lists are empty
* @dlist: Pointer to the dlock_list_heads structure
- * Return: true if list is empty, false otherwise.
*
- * This can be a pretty expensive function call. If this function is required
- * in a performance critical path, we may have to maintain a global count
- * of the list entries in the global dlock_list_heads structure instead.
+ * Return: true if all dlock lists are empty, false otherwise. */
bool dlock_lists_empty(struct dlock_list_heads *dlist)
{
- int idx;
-
/* Shouldn't be called before nr_dlock_lists is initialized */ WARN_ON_ONCE(!nr_dlock_lists);
- for (idx = 0; idx < nr_dlock_lists; idx++)
- if (!list_empty(&dlist->heads[idx].list))
- return false;
- return true;
+ /*
+ * Serialize dlist->used_lists such that a 0->1 transition is not
+ * missed by another thread checking if any of the dlock lists are
+ * used.
+ *
+ * CPU0 CPU1
+ * dlock_list_add() dlock_lists_empty()
+ * [S] atomic_inc(used_lists);
+ * smp_mb__after_atomic();
+ * smp_mb__before_atomic();
+ * [L] atomic_read(used_lists)
+ * list_add()
+ */
+ smp_mb__before_atomic();
+ return !atomic_read(&dlist->used_lists);
}EXPORT_SYMBOL(dlock_lists_empty);
@@ -177,11 +187,39 @@ void dlock_lists_add(struct dlock_list_node *node,
struct dlock_list_heads *dlist)
{
struct dlock_list_head *head = &dlist->heads[this_cpu_read(cpu2idx)];+ bool list_empty_before_lock = false;
+
+ /*
+ * Optimistically bump the used_lists counter _before_ taking
+ * the head->lock such that we don't miss a thread adding itself
+ * to a list while spinning for the lock.
+ *
+ * Then, after taking the lock, recheck if the empty to non-empty
+ * transition changed and (un)account for ourselves, accordingly.
+ * Note that all these scenarios are corner cases, and not the
+ * common scenario, where the lists are actually populated most
+ * of the time.
+ */
+ if (unlikely(list_empty_careful(&head->list))) {
+ list_empty_before_lock = true;
+ atomic_inc(&dlist->used_lists);
+ smp_mb__after_atomic();
+ }
/* * There is no need to disable preemption */ spin_lock(&head->lock);
+
+ if (unlikely(!list_empty_before_lock && list_empty(&head->list))) {
+ atomic_inc(&dlist->used_lists);
+ smp_mb__after_atomic();
+ }
+ if (unlikely(list_empty_before_lock && !list_empty(&head->list))) {
+ atomic_dec(&dlist->used_lists);
+ smp_mb__after_atomic();
+ }
+
node->head = head;
list_add(&node->list, &head->list);
spin_unlock(&head->lock);
@@ -212,6 +250,15 @@ void dlock_lists_del(struct dlock_list_node *node)
spin_lock(&head->lock);
if (likely(head == node->head)) {
list_del_init(&node->list);+
+ if (unlikely(list_empty(&head->list))) {
+ struct dlock_list_heads *dlist;
+ dlist = node->head->dlist;
+
+ atomic_dec(&dlist->used_lists);
+ smp_mb__after_atomic();
+ }
+
node->head = NULL;
retry = false;
} else {Signature · 1 line
2.13.6
Re: [PATCH v4] lib/dlock-list: Scale dlock_lists_empty()
Quoted 161 lines · Davidlohr Bueso
Instead of the current O(N) implementation, at the cost of adding an atomic counter, we can convert the call to an
atomic_read(). The counter only serves for accounting empty to non-empty transitions, and vice versa; therefore only modified twice for each of the lists during the lifetime of the dlock (while used).In addition, to be able to unaccount a
list_del(), we add a dlist pointer to each head, thus minimizing the overall memory footprint.Signed-off-by Davidlohr Bueso <[email protected]>---
Changes from v3:
- s/waiters/used_lists, more doc around the counter.
- fixed racy scenario when the list empty/non-empty condition changes after taking the lock.
- sprinkledunlikely()around all checks, these are only corner cases in the lifetime of the lock.
include/linux/dlock-list.h| 8 ++++++lib/dlock-list.c| 67
+++++++++++++++++++++++++++++++++++++++-------2 files changed, 65 insertions(+), 10 deletions(-)include/linux/dlock-list.h +8
-0@@ -32,10 +32,18 @@struct dlock_list_head {struct list_head list;spinlock_t lock; +struct dlock_list_heads *dlist; }____cacheline_aligned_in_smp ; +/* +* This is the main dlist data structure, with the array of heads +* and a counter that atomically tracks if any of the lists are +* being used. That is, empty to non-empty (and vice versa) +* head->list transitions. +*/ struct dlock_list_heads {struct dlock_list_head *heads; +atomic_t used_lists; };/* lib/dlock-list.c +3
-0@@ -122,8 +122,11 @@ int __alloc_dlock_list_heads(struct dlock_list_heads *dlist,INIT_LIST_HEAD (&head->list); head->lock =__SPIN_LOCK_UNLOCKED (&head->lock); + head->dlist = dlist;lockdep_set_class (&head->lock, key); } + +atomic_set (&dlist->used_lists,0 );return 0 ; }
EXPORT_SYMBOL(__alloc_dlock_list_heads);lib/dlock-list.c +1
-2@@ -139,29 +142,36 @@ void free_dlock_list_heads(struct dlock_list_heads *dlist) {kfree (dlist->heads); dlist->heads =NULL ; +atomic_set (&dlist->used_lists,0 ); }EXPORT_SYMBOL (free_dlock_list_heads);/** * dlock_lists_empty - Check if all the dlock lists are empty * @dlist: Pointer to the dlock_list_heads structure -* Return: true if list is empty, false otherwise. * -* This can be a pretty expensive function call. If this function is required
- * in a performance critical path, we may have to maintain a global count
- * of the list entries in the globaldlock_list_headsstructure instead.
+ * Return: true if all dlock lists are empty, false otherwise. */
booldlock_lists_empty(struct dlock_list_heads *dlist)
{lib/dlock-list.c +15
-6-int idx; -/* Shouldn't be called before nr_dlock_lists is initialized */ WARN_ON_ONCE (!nr_dlock_lists); -for (idx =0 ; idx < nr_dlock_lists; idx++) -if (!list_empty (&dlist->heads[idx].list)) -return false; -return true; +/* +* Serialize dlist->used_lists such that a 0->1 transition is not +* missed by another thread checking if any of the dlock lists are +* used. +* +* CPU0 CPU1 +* dlock_list_add() dlock_lists_empty() +* [S] atomic_inc(used_lists); +* smp_mb__after_atomic(); +* smp_mb__before_atomic(); +* [L] atomic_read(used_lists) +* list_add() +*/ +smp_mb__before_atomic (); +return !atomic_read (&dlist->used_lists);}
EXPORT_SYMBOL(dlock_lists_empty);lib/dlock-list.c +30
-0@@ -177,11 +187,39 @@ void dlock_lists_add(struct dlock_list_node *node, struct dlock_list_heads *dlist) {struct dlock_list_head *head = &dlist->heads[this_cpu_read (cpu2idx)]; +bool list_empty_before_lock = false; + +/* +* Optimistically bump the used_lists counter _before_ taking +* the head->lock such that we don't miss a thread adding itself +* to a list while spinning for the lock. +* +* Then, after taking the lock, recheck if the empty to non-empty +* transition changed and (un)account for ourselves, accordingly. +* Note that all these scenarios are corner cases, and not the +* common scenario, where the lists are actually populated most +* of the time. +*/ +if (unlikely (list_empty_careful (&head->list))) { + list_empty_before_lock = true; +atomic_inc (&dlist->used_lists); +smp_mb__after_atomic (); + }/* * There is no need to disable preemption */ spin_lock (&head->lock); + +if (unlikely (!list_empty_before_lock &&list_empty (&head->list))) { +atomic_inc (&dlist->used_lists); +smp_mb__after_atomic (); + } +if (unlikely (list_empty_before_lock && !list_empty (&head->list))) { +atomic_dec (&dlist->used_lists); +smp_mb__after_atomic (); + } + node->head = head;list_add (&node->list, &head->list);spin_unlock (&head->lock);@@ -212,6 +250,15 @@ void dlock_lists_del(struct dlock_list_node *node)spin_lock (&head->lock);if (likely (head == node->head)) {list_del_init (&node->list); + +if (unlikely (list_empty (&head->list))) {
lib/dlock-list.c void dlock_lists_del(struct dlock_list_node *node) · line 264
Quoted 10 lines
lib/dlock-list.c +7
-0+struct dlock_list_heads *dlist; + dlist = node->head->dlist; + +atomic_dec (&dlist->used_lists); +smp_mb__after_atomic (); + } + node->head =NULL ; retry = false; }else {
This patch looks good to me.
Re: [PATCH v4] lib/dlock-list: Scale dlock_lists_empty()
In reply to Davidlohr BuesoQuoted 7 lines · Davidlohr Bueso
Instead of the current O(N) implementation, at the cost of adding an atomic counter, we can convert the call to an
atomic_read(). The counter only serves for accounting empty to non-empty transitions, and vice versa; therefore only modified twice for each of the lists during the lifetime of the dlock (while used).
Quoted 5 lines
In addition, to be able to unaccount a
list_del(), we add a dlist pointer to each head, thus minimizing the overall memory footprint.Signed-off-by Davidlohr Bueso <[email protected]>
Looks good to me. You can add:
Honza Kara
Quoted 157 lines
---
Changes from v3:
- s/waiters/used_lists, more doc around the counter.
- fixed racy scenario when the list empty/non-empty condition changes after taking the lock.
- sprinkledunlikely()around all checks, these are only corner cases in the lifetime of the lock.
include/linux/dlock-list.h| 8 ++++++lib/dlock-list.c| 67 +++++++++++++++++++++++++++++++++++++++-------2 files changed, 65 insertions(+), 10 deletions(-)include/linux/dlock-list.h +8
-0@@ -32,10 +32,18 @@struct dlock_list_head {struct list_head list;spinlock_t lock; +struct dlock_list_heads *dlist; }____cacheline_aligned_in_smp ; +/* +* This is the main dlist data structure, with the array of heads +* and a counter that atomically tracks if any of the lists are +* being used. That is, empty to non-empty (and vice versa) +* head->list transitions. +*/ struct dlock_list_heads {struct dlock_list_head *heads; +atomic_t used_lists; };/* lib/dlock-list.c +57
-10@@ -122,8 +122,11 @@ int __alloc_dlock_list_heads(struct dlock_list_heads *dlist,INIT_LIST_HEAD (&head->list); head->lock =__SPIN_LOCK_UNLOCKED (&head->lock); + head->dlist = dlist;lockdep_set_class (&head->lock, key); } + +atomic_set (&dlist->used_lists,0 );return 0 ; }EXPORT_SYMBOL (__alloc_dlock_list_heads);@@ -139,29 +142,36 @@ void free_dlock_list_heads(struct dlock_list_heads *dlist) {kfree (dlist->heads); dlist->heads =NULL ; +atomic_set (&dlist->used_lists,0 ); }EXPORT_SYMBOL (free_dlock_list_heads);/** * dlock_lists_empty - Check if all the dlock lists are empty * @dlist: Pointer to the dlock_list_heads structure -* Return: true if list is empty, false otherwise. * -* This can be a pretty expensive function call. If this function is required -* in a performance critical path, we may have to maintain a global count -* of the list entries in the global dlock_list_heads structure instead. +* Return: true if all dlock lists are empty, false otherwise. */ bool dlock_lists_empty (struct dlock_list_heads *dlist) { -int idx; -/* Shouldn't be called before nr_dlock_lists is initialized */ WARN_ON_ONCE (!nr_dlock_lists); -for (idx =0 ; idx < nr_dlock_lists; idx++) -if (!list_empty (&dlist->heads[idx].list)) -return false; -return true; +/* +* Serialize dlist->used_lists such that a 0->1 transition is not +* missed by another thread checking if any of the dlock lists are +* used. +* +* CPU0 CPU1 +* dlock_list_add() dlock_lists_empty() +* [S] atomic_inc(used_lists); +* smp_mb__after_atomic(); +* smp_mb__before_atomic(); +* [L] atomic_read(used_lists) +* list_add() +*/ +smp_mb__before_atomic (); +return !atomic_read (&dlist->used_lists); }EXPORT_SYMBOL (dlock_lists_empty);@@ -177,11 +187,39 @@ void dlock_lists_add(struct dlock_list_node *node, struct dlock_list_heads *dlist) {struct dlock_list_head *head = &dlist->heads[this_cpu_read (cpu2idx)]; +bool list_empty_before_lock = false; + +/* +* Optimistically bump the used_lists counter _before_ taking +* the head->lock such that we don't miss a thread adding itself +* to a list while spinning for the lock. +* +* Then, after taking the lock, recheck if the empty to non-empty +* transition changed and (un)account for ourselves, accordingly. +* Note that all these scenarios are corner cases, and not the +* common scenario, where the lists are actually populated most +* of the time. +*/ +if (unlikely (list_empty_careful (&head->list))) { + list_empty_before_lock = true; +atomic_inc (&dlist->used_lists); +smp_mb__after_atomic (); + }/* * There is no need to disable preemption */ spin_lock (&head->lock); + +if (unlikely (!list_empty_before_lock &&list_empty (&head->list))) { +atomic_inc (&dlist->used_lists); +smp_mb__after_atomic (); + } +if (unlikely (list_empty_before_lock && !list_empty (&head->list))) { +atomic_dec (&dlist->used_lists); +smp_mb__after_atomic (); + } + node->head = head;list_add (&node->list, &head->list);spin_unlock (&head->lock);@@ -212,6 +250,15 @@ void dlock_lists_del(struct dlock_list_node *node)spin_lock (&head->lock);if (likely (head == node->head)) {list_del_init (&node->list); + +if (unlikely (list_empty (&head->list))) { +struct dlock_list_heads *dlist; + dlist = node->head->dlist; + +atomic_dec (&dlist->used_lists); +smp_mb__after_atomic (); + } + node->head =NULL ; retry = false; }else {Signature · 1 line
2.13.6
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Re: [PATCH v4] lib/dlock-list: Scale dlock_lists_empty()
Quoted 16 lines · Jan Kara
Quoted 5 lines · Davidlohr Bueso
(quoted diff) +5
-0+ /* + * Serialize dlist->used_lists such that a 0->1 transition is not + * missed by another thread checking if any of the dlock lists are + * used. + *Review
Quoted 10 lines
(quoted diff) +10
-0+ * CPU0 CPU1 + * dlock_list_add() dlock_lists_empty() + * [S] atomic_inc(used_lists); + * smp_mb__after_atomic(); + * smp_mb__before_atomic(); + * [L] atomic_read(used_lists) + * list_add() + */ + smp_mb__before_atomic(); + return !atomic_read(&dlist->used_lists);
Just a general kernel programming question here - I thought the whole point of atomics is that they are, well, atomic across all CPUs so there is no need for a memory barrier? If there is a need for a memory barrier for each atomic access (assuming it isn't accessed under another lock, which would make the use of atomic types pointless, IMHO) then I'd think there is a lot of code in the kernel that isn't doing this properly.
What am I missing here?
I don't see how this helps if the operations are executed like:
* CPU0 CPU1
* dlock_list_add() dlock_lists_empty()
* [S] atomic_inc(used_lists);
* smp_mb__before_atomic();
* smp_mb__after_atomic();
* [L] atomic_read(used_lists)
or alternately like:
* CPU0 CPU1
* dlock_list_add() dlock_lists_empty()
* smp_mb__before_atomic();
* [S] atomic_inc(used_lists);
* smp_mb__after_atomic();
* [L] atomic_read(used_lists)
then the same problem would exist, unless those functions/macros are somehow bound to the atomic operations themselves? In that case, what makes the use of atomic_{inc,dec,read}() in other parts of the code safe without them?
Cheers, Andreas
Re: [PATCH v4] lib/dlock-list: Scale dlock_lists_empty()
Quoted 24 lines · Andreas Dilger
Quoted 16 lines · Jan Kara
Quoted 5 lines · Davidlohr Bueso
(quoted diff) +5
-0+ /* + * Serialize dlist->used_lists such that a 0->1 transition is not + * missed by another thread checking if any of the dlock lists are + * used. + *Review
Quoted 10 lines
(quoted diff) +10
-0+ * CPU0 CPU1 + * dlock_list_add() dlock_lists_empty() + * [S] atomic_inc(used_lists); + * smp_mb__after_atomic(); + * smp_mb__before_atomic(); + * [L] atomic_read(used_lists) + * list_add() + */ + smp_mb__before_atomic(); + return !atomic_read(&dlist->used_lists);Just a general kernel programming question here - I thought the whole point of atomics is that they are, well, atomic across all CPUs so there is no need for a memory barrier? If there is a need for a memory barrier for each atomic access (assuming it isn't accessed under another lock, which would make the use of atomic types pointless, IMHO) then I'd think there is a lot of code in the kernel that isn't doing this properly.
Quoted 1 line
What am I missing here?
Atomic update and memory barrier are 2 different things. Atomic update means other CPUs see either the value before or after the update. They won't see anything in between. For a counter, it means we won't miss any counts. However, not all atomic operations give an ordering guarantee. The atomic_read() and atomic_inc() are examples that do not provide memory ordering guarantee. See Documentation/memory-barriers.txt for more information about it.
A CPU can perform atomic operations 1 & 2 in program order, but other CPUs may see operation 2 first before operation 1. Here memory barrier can be used to guarantee that other CPUs see the memory updates in certain order.
Hope this help.
Longman
Re: [PATCH v4] lib/dlock-list: Scale dlock_lists_empty()
Quoted 44 lines · Waiman Long
Quoted 33 lines · Andreas Dilger
Quoted 15 lines · Jan Kara
Quoted 13 lines · Davidlohr Bueso
(quoted diff) +2
-0+ /* + * Serialize dlist->used_lists such that a 0->1transition is not
(quoted diff) +1
-0+ * missed by another thread checking if any of thedlock lists are
(quoted diff) +4
-0+ * used. + * + * CPU0 CPU1 + *dlock_list_add() dlock_lists_empty()
(quoted diff) +2
-0+ * [S] atomic_inc(used_lists); + * smp_mb__after_atomic();Quoted 8 lines
Review
Quoted 8 lines
(quoted diff) +1
-0+ * smp_mb__be
fore_atomic();(quoted diff) +1
-0+ * [L]
atomic_read(used_lists)(quoted diff) +4
-0+ * list_add() + */ + smp_mb__before_atomic(); + return !atomic_read(&dlist->used_lists);Just a general kernel programming question here - I thought the whole point of atomics is that they are, well, atomic across all CPUs so there is no need for a memory barrier? If there is a need for a memory barrier for each atomic access (assuming it isn't accessed under another lock, which would make the use of atomic types pointless, IMHO) then I'd think there is a lot of code in the kernel that isn't doing this properly.
Quoted 1 line
What am I missing here?
Atomic update and memory barrier are 2 different things. Atomic update means other CPUs see either the value before or after the update. They won't see anything in between. For a counter, it means we won't miss any counts. However, not all atomic operations give an ordering guarantee. The
atomic_read()andatomic_inc()are examples that do not provide memory ordering guarantee. SeeDocumentation/memory-barriers.txtfor more information about it.
Quoted 4 lines
A CPU can perform atomic operations 1 & 2 in program order, but other CPUs may see operation 2 first before operation 1. Here memory barrier can be used to guarantee that other CPUs see the memory updates in certain order.
There's an omission here which I think Andreas may have been referring
to: atomic_inc/dec operations *are* strongly ordered with respect to each other, so if two CPUs are simultaneously executing atomic_inc, the order in which they execute isn't guaranteed, but it is guaranteed that the losing atomic_inc will not begin until the winning one is completed, so after both are done the value will have +2. So although atomic_read and atomic_inc have no ordering guarantee at all (the point of the barrier above), if you're looking at the return values of atomic_inc/dec you don't need a barrier because regardless of which order the CPUs go in, they'll see distinct values (we use this for reference counting).
James
Re: [PATCH v4] lib/dlock-list: Scale dlock_lists_empty()
In reply to Andreas DilgerQuoted 36 lines · Andreas Dilger
Quoted 16 lines · Jan Kara
Quoted 5 lines · Davidlohr Bueso
(quoted diff) +5
-0+ /* + * Serialize dlist->used_lists such that a 0->1 transition is not + * missed by another thread checking if any of the dlock lists are + * used. + *Review
Quoted 10 lines
(quoted diff) +10
-0+ * CPU0 CPU1 + * dlock_list_add() dlock_lists_empty() + * [S] atomic_inc(used_lists); + * smp_mb__after_atomic(); + * smp_mb__before_atomic(); + * [L] atomic_read(used_lists) + * list_add() + */ + smp_mb__before_atomic(); + return !atomic_read(&dlist->used_lists);Just a general kernel programming question here - I thought the whole point of atomics is that they are, well, atomic across all CPUs so there is no need for a memory barrier? If there is a need for a memory barrier for each atomic access (assuming it isn't accessed under another lock, which would make the use of atomic types pointless, IMHO) then I'd think there is a lot of code in the kernel that isn't doing this properly.
What am I missing here?
I don't see how this helps if the operations are executed like:
* CPU0 CPU1
*dlock_list_add()dlock_lists_empty()
* [S]atomic_inc(used_lists);
*smp_mb__before_atomic();
*smp_mb__after_atomic();
* [L]atomic_read(used_lists)
Quoted 9 lines
or alternately like:
* CPU0 CPU1
*dlock_list_add()dlock_lists_empty()
*smp_mb__before_atomic();
* [S]atomic_inc(used_lists);
*smp_mb__after_atomic();
* [L]atomic_read(used_lists)
Or worse:
* CPU0 CPU1
* dlock_list_add() dlock_lists_empty()
* smp_mb__before_atomic();
* [L] atomic_read(used_lists)
* [S] atomic_inc(used_lists);
* smp_mb__after_atomic();
, in which case dlock_lists_empty() misses a increment of used_lists.
That said, this may be fine for the usage of dlock_list. But I think the comments are confusing or wrong. The reason is you can not use barriers to order two memory ops on different CPUs, and usually we add comments like:
[S] ... [S] ... <barrier> <barrier> [L] ... [L] ...
Davidlohr, could you try to improve the comments by finding both memory ops preceding and following the barriers? Maybe you will find those barriers are not necessary in the end.
Regards,
Boqun
Quoted 10 lines
then the same problem would exist, unless those functions/macros are somehow bound to the atomic operations themselves? In that case, what makes the use of atomic_{inc,dec,read}() in other parts of the code safe without them?
Cheers, Andreas
Re: [PATCH v4] lib/dlock-list: Scale dlock_lists_empty()
Quoted 9 lines · Boqun Feng
Or worse:
* CPU0 CPU1
*dlock_list_add()dlock_lists_empty()
*smp_mb__before_atomic();
* [L]atomic_read(used_lists)
* [S]atomic_inc(used_lists);
*smp_mb__after_atomic();
Quoted 6 lines
, in which case
dlock_lists_empty()misses a increment ofused_lists.That said, this may be fine for the usage of
dlock_list. But I think the comments are confusing or wrong. The reason is you can not use barriers to order two memory ops on different CPUs, and usually we add comments like:
So I think that case is OK as CPU1 legitimately reads a 0, the problem would be if we miss the inc it because we are doing spin_lock().
Quoted 4 lines
[S] ... [S] ... <barrier> <barrier> [L] ... [L] ...
That is true.
Quoted 4 lines
Davidlohr, could you try to improve the comments by finding both memory ops preceding and following the barriers? Maybe you will find those barriers are not necessary in the end.
Ok so for the dlock_list_add() the first barrier is so that the atomic_inc() is not done inside the critical region, after the head->lock is taken. The other barriers that follow I put such that the respective atomic op is done before the list_add(), however thinking about it I don't think they are really needed.
Regarding dlock_list_empty(), the smp_mb__before_atomic() is mainly for pairing reasons; but at this point I don't see a respective counterpart for the above diagram so I'm unclear.
Thanks,
Davidlohr
Re: [PATCH v4] lib/dlock-list: Scale dlock_lists_empty()
Quoted 7 lines · Davidlohr Bueso
Quoted 6 lines · Boqun Feng
Or worse:
* CPU0 CPU1 * dlock_list_add() dlock_lists_empty() * smp_mb__before_atomic(); * [L] atomic_read(used_lists)
Note that this is broken; smp_mb__before_atomic() is not valid on atomic_read().
Quoted 3 lines
Quoted 3 lines
* [S]
atomic_inc(used_lists);
*smp_mb__after_atomic();
Re: [PATCH v8 1/6] lib/dlock-list: Distributed and lock-protected lists
In reply to Waiman LongQuoted 33 lines · Waiman Long
Linked list is used everywhere in the Linux kernel. However, if many threads are trying to add or delete entries into the same linked list, it can create a performance bottleneck.
This patch introduces a new list APIs that provide a set of distributed lists (one per CPU), each of which is protected by its own spinlock. To the callers, however, the set of lists acts like a single consolidated list. This allows list entries insertion and deletion operations to happen in parallel instead of being serialized with a global list and lock.
List entry insertion is strictly per cpu. List deletion, however, can happen in a cpu other than the one that did the insertion. So we still need lock to protect the list. Because of that, there may still be a small amount of contention when deletion is being done.
A new header file
include/linux/dlock-list.hwill be added with the associateddlock_list_headanddlock_list_nodestructures. The following functions are provided to manage the per-cpu list:1. int
alloc_dlock_list_heads(struct dlock_list_heads *dlist)
2. voidfree_dlock_list_heads(struct dlock_list_heads *dlist)
3. voiddlock_list_add(struct dlock_list_node *node, struct dlock_list_heads *dlist)
4. voiddlock_list_del(struct dlock_list *node)Iteration of all the list entries within a dlock list array is done by calling either the
dlist_for_each_entry()ordlist_for_each_entry_safe()macros. They correspond to thelist_for_each_entry()andlist_for_each_entry_safe()macros respectively. The iteration states are keep in adlock_list_iterstructure that is passed to the iteration macros.
Quoted 2 lines
Signed-off-by Waiman Long <[email protected]>Reviewed-by Jan Kara <[email protected]>
PATCH v8 2/6 vfs: Remove unnecessary list_for_each_entry_safe() variants
In reply to Waiman LongFrom: Jan Kara <[email protected]>
evict_inodes() and invalidate_inodes() use list_for_each_entry_safe() to iterate sb->s_inodes list. However, since we use i_lru list entry for our local temporary list of inodes to destroy, the inode is guaranteed to stay in sb->s_inodes list while we hold sb->s_inode_list_lock. So there is no real need for safe iteration variant and we can use list_for_each_entry() just fine.
--- fs/inode.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
fs/inode.c +4 -4
@@ -601,12 +601,12 @@ static void dispose_list(struct list_head *head)*/ void evict_inodes (struct super_block *sb) { -struct inode *inode, *next; +struct inode *inode;LIST_HEAD (dispose); again:spin_lock (&sb->s_inode_list_lock); -list_for_each_entry_safe (inode, next, &sb->s_inodes, i_sb_list) { +list_for_each_entry (inode, &sb->s_inodes, i_sb_list) {if (atomic_read (&inode->i_count))continue ;
@@ -652,11 +652,11 @@ void evict_inodes(struct super_block *sb)int invalidate_inodes (struct super_block *sb,bool kill_dirty) {int busy =0 ; -struct inode *inode, *next; +struct inode *inode;LIST_HEAD (dispose);spin_lock (&sb->s_inode_list_lock); -list_for_each_entry_safe (inode, next, &sb->s_inodes, i_sb_list) { +list_for_each_entry (inode, &sb->s_inodes, i_sb_list) {spin_lock (&inode->i_lock);if (inode->i_state & (I_NEW |I_FREEING |I_WILL_FREE )) {spin_unlock (&inode->i_lock);
Signature · 1 line
1.8.3.1
PATCH v8 3/6 vfs: Use dlock list for superblock's inode list
In reply to Waiman LongWhen many threads are trying to add or delete inode to or from a superblock's s_inodes list, spinlock contention on the list can become a performance bottleneck.
This patch changes the s_inodes field to become a dlock list which is a distributed set of lists with per-list spinlocks. As a result, the following superblock inode list (sb->s_inodes) iteration functions in vfs are also being modified:
1. iterate_bdevs()
2. drop_pagecache_sb()
3. evict_inodes()
4. invalidate_inodes()
5. fsnotify_unmount_inodes()
6. add_dquot_ref()
7. remove_dquot_ref()
With an exit microbenchmark that creates a large number of threads, attachs many inodes to them and then exits. The runtimes of that microbenchmark with 1200 threads before and after the patch on a 2-socket Intel E5-2699 v3 system (36 cores, 72 threads) were as follows:
Kernel Elapsed Time System Time ------ ------------ ----------- Vanilla 4.14-rc3 58.40s 65m20s Patched 4.14-rc3 42.17s 45m32s
Before the patch, spinlock contention at the inode_sb_list_add() function at the startup phase and the evict() function at the teardown phase were about 68% and 97% of total CPU time respectively (as measured by perf). With the patched kernel, the inode_sb_list_add() function is less than 1% and the evict() function is at 2.5% respectively. There were still quite a lot of lock contention elsewhere that limited the gain. For example, the nlru lock was contributing most of the lock contention in the teardown phase.
--- fs/block_dev.c | 9 ++++----- fs/drop_caches.c | 9 ++++----- fs/inode.c | 34 +++++++++++++--------------------- fs/notify/fsnotify.c | 9 ++++----- fs/quota/dquot.c | 14 ++++++-------- fs/super.c | 7 ++++--- include/linux/fs.h | 8 ++++---- 7 files changed, 39 insertions(+), 51 deletions(-)
fs/block_dev.c +4 -5
@@ -2127,9 +2127,9 @@ int __invalidate_device(struct block_device *bdev, bool kill_dirty)void iterate_bdevs (void (*func)(struct block_device *,void *),void *arg) {struct inode *inode, *old_inode =NULL ; +DEFINE_DLOCK_LIST_ITER (iter, &blockdev_superblock->s_inodes); -spin_lock (&blockdev_superblock->s_inode_list_lock); -list_for_each_entry (inode, &blockdev_superblock->s_inodes, i_sb_list) { +dlist_for_each_entry (inode, &iter, i_sb_list) {struct address_space *mapping = inode->i_mapping;struct block_device *bdev;
@@ -2141,7 +2141,7 @@ void iterate_bdevs(void (*func)(struct block_device *, void *), void *arg) }__iget (inode);spin_unlock (&inode->i_lock); -spin_unlock (&blockdev_superblock->s_inode_list_lock); +dlock_list_unlock (&iter);/* * We hold a reference to 'inode' so it couldn't have been * removed from s_inodes list while we dropped the
@@ -2159,8 +2159,7 @@ void iterate_bdevs(void (*func)(struct block_device *, void *), void *arg)func (bdev, arg);mutex_unlock (&bdev->bd_mutex); -spin_lock (&blockdev_superblock->s_inode_list_lock); +dlock_list_relock (&iter); } -spin_unlock (&blockdev_superblock->s_inode_list_lock);iput (old_inode); }
fs/drop_caches.c +4 -5
@@ -16,9 +16,9 @@static void drop_pagecache_sb (struct super_block *sb,void *unused) {struct inode *inode, *toput_inode =NULL ; +DEFINE_DLOCK_LIST_ITER (iter, &sb->s_inodes); -spin_lock (&sb->s_inode_list_lock); -list_for_each_entry (inode, &sb->s_inodes, i_sb_list) { +dlist_for_each_entry (inode, &iter, i_sb_list) {spin_lock (&inode->i_lock);if ((inode->i_state & (I_FREEING |I_WILL_FREE |I_NEW )) || (inode->i_mapping->nrpages ==0 )) {
@@ -27,15 +27,14 @@ static void drop_pagecache_sb(struct super_block *sb, void *unused) }__iget (inode);spin_unlock (&inode->i_lock); -spin_unlock (&sb->s_inode_list_lock); +dlock_list_unlock (&iter);invalidate_mapping_pages (inode->i_mapping,0 ,-1 );iput (toput_inode); toput_inode = inode; -spin_lock (&sb->s_inode_list_lock); +dlock_list_relock (&iter); } -spin_unlock (&sb->s_inode_list_lock);iput (toput_inode); }
fs/inode.c +13 -21
@@ -28,7 +28,7 @@* inode->i_state, inode->i_hash, __iget() * Inode LRU list locks protect: * inode->i_sb->s_inode_lru, inode->i_lru -* inode->i_sb->s_inode_list_lock protects: +* inode->i_sb->s_inodes->head->lock protects: * inode->i_sb->s_inodes, inode->i_sb_list * bdi->wb.list_lock protects: * bdi->wb.b_{dirty,io,more_io,dirty_time}, inode->i_io_list
@@ -37,7 +37,7 @@* * Lock ordering: * -* inode->i_sb->s_inode_list_lock +* inode->i_sb->s_inodes->head->lock * inode->i_lock * Inode LRU list locks *
@@ -45,7 +45,7 @@* inode->i_lock * * inode_hash_lock -* inode->i_sb->s_inode_list_lock +* inode->i_sb->s_inodes->head->lock * inode->i_lock * * iunique_lock
@@ -434,19 +434,14 @@ static void inode_lru_list_del(struct inode *inode)*/ void inode_sb_list_add (struct inode *inode) { -spin_lock (&inode->i_sb->s_inode_list_lock); -list_add (&inode->i_sb_list, &inode->i_sb->s_inodes); -spin_unlock (&inode->i_sb->s_inode_list_lock); +dlock_lists_add (&inode->i_sb_list, &inode->i_sb->s_inodes); }EXPORT_SYMBOL_GPL (inode_sb_list_add);static inline void inode_sb_list_del (struct inode *inode) { -if (!list_empty (&inode->i_sb_list)) { -spin_lock (&inode->i_sb->s_inode_list_lock); -list_del_init (&inode->i_sb_list); -spin_unlock (&inode->i_sb->s_inode_list_lock); - } +if (!list_empty (&inode->i_sb_list.list)) +dlock_lists_del (&inode->i_sb_list); }static unsigned long hash (struct super_block *sb,unsigned long hashval)
@@ -602,11 +597,12 @@ static void dispose_list(struct list_head *head)void evict_inodes (struct super_block *sb) {struct inode *inode; +struct dlock_list_iter iter;LIST_HEAD (dispose); again: -spin_lock (&sb->s_inode_list_lock); -list_for_each_entry (inode, &sb->s_inodes, i_sb_list) { +init_dlock_list_iter (&iter, &sb->s_inodes); +dlist_for_each_entry (inode, &iter, i_sb_list) {if (atomic_read (&inode->i_count))continue ;
@@ -627,13 +623,12 @@ void evict_inodes(struct super_block *sb)* bit so we don't livelock. */ if (need_resched ()) { -spin_unlock (&sb->s_inode_list_lock); +dlock_list_unlock (&iter);cond_resched ();dispose_list (&dispose); goto again; } } -spin_unlock (&sb->s_inode_list_lock);dispose_list (&dispose); }
@@ -654,9 +649,9 @@ int invalidate_inodes(struct super_block *sb, bool kill_dirty)int busy =0 ;struct inode *inode;LIST_HEAD (dispose); +DEFINE_DLOCK_LIST_ITER (iter, &sb->s_inodes); -spin_lock (&sb->s_inode_list_lock); -list_for_each_entry (inode, &sb->s_inodes, i_sb_list) { +dlist_for_each_entry (inode, &iter, i_sb_list) {spin_lock (&inode->i_lock);if (inode->i_state & (I_NEW |I_FREEING |I_WILL_FREE )) {spin_unlock (&inode->i_lock);
@@ -678,7 +673,6 @@ int invalidate_inodes(struct super_block *sb, bool kill_dirty)spin_unlock (&inode->i_lock);list_add (&inode->i_lru, &dispose); } -spin_unlock (&sb->s_inode_list_lock);dispose_list (&dispose);
@@ -893,7 +887,7 @@ struct inode *new_inode_pseudo(struct super_block *sb)spin_lock (&inode->i_lock); inode->i_state =0 ;spin_unlock (&inode->i_lock); -INIT_LIST_HEAD (&inode->i_sb_list); +init_dlock_list_node (&inode->i_sb_list); }return inode; }
@@ -914,8 +908,6 @@ struct inode *new_inode(struct super_block *sb) {struct inode *inode; -spin_lock_prefetch (&sb->s_inode_list_lock); - inode =new_inode_pseudo (sb);if (inode)inode_sb_list_add (inode);
fs/notify/fsnotify.c +4 -5
@@ -51,9 +51,9 @@ void __fsnotify_vfsmount_delete(struct vfsmount *mnt)void fsnotify_unmount_inodes (struct super_block *sb) {struct inode *inode, *iput_inode =NULL ; +DEFINE_DLOCK_LIST_ITER (iter, &sb->s_inodes); -spin_lock (&sb->s_inode_list_lock); -list_for_each_entry (inode, &sb->s_inodes, i_sb_list) { +dlist_for_each_entry (inode, &iter, i_sb_list) {/* * We cannot __iget() an inode in state I_FREEING, * I_WILL_FREE, or I_NEW which is fine because by that point
@@ -78,7 +78,7 @@ void fsnotify_unmount_inodes(struct super_block *sb)__iget (inode);spin_unlock (&inode->i_lock); -spin_unlock (&sb->s_inode_list_lock); +dlock_list_unlock (&iter);if (iput_inode)iput (iput_inode);
@@ -90,9 +90,8 @@ void fsnotify_unmount_inodes(struct super_block *sb) iput_inode = inode; -spin_lock (&sb->s_inode_list_lock); +dlock_list_relock (&iter); } -spin_unlock (&sb->s_inode_list_lock);if (iput_inode)iput (iput_inode);
fs/quota/dquot.c +6 -8
@@ -936,12 +936,12 @@ static int dqinit_needed(struct inode *inode, int type)static void add_dquot_ref (struct super_block *sb,int type) {struct inode *inode, *old_inode =NULL ; +DEFINE_DLOCK_LIST_ITER (iter, &sb->s_inodes);#ifdef CONFIG_QUOTA_DEBUG int reserved =0 ;#endif -spin_lock (&sb->s_inode_list_lock); -list_for_each_entry (inode, &sb->s_inodes, i_sb_list) { +dlist_for_each_entry (inode, &iter, i_sb_list) {spin_lock (&inode->i_lock); if ((inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) || !atomic_read(&inode->i_writecount) ||
@@ -951,7 +951,7 @@ static void add_dquot_ref(struct super_block *sb, int type) }__iget (inode);spin_unlock (&inode->i_lock); -spin_unlock (&sb->s_inode_list_lock); +dlock_list_unlock (&iter);#ifdef CONFIG_QUOTA_DEBUG if (unlikely (inode_get_rsv_space (inode) >0 ))
@@ -969,9 +969,8 @@ static void add_dquot_ref(struct super_block *sb, int type)* later. */ old_inode = inode; -spin_lock (&sb->s_inode_list_lock); +dlock_list_relock (&iter); } -spin_unlock (&sb->s_inode_list_lock);iput (old_inode);#ifdef CONFIG_QUOTA_DEBUG
@@ -1039,9 +1038,9 @@ static void remove_dquot_ref(struct super_block *sb, int type, {struct inode *inode;int reserved =0 ; +DEFINE_DLOCK_LIST_ITER (iter, &sb->s_inodes); -spin_lock (&sb->s_inode_list_lock); -list_for_each_entry (inode, &sb->s_inodes, i_sb_list) { +dlist_for_each_entry (inode, &iter, i_sb_list) {/* * We have to scan also I_NEW inodes because they can already * have quota pointer initialized. Luckily, we need to touch
@@ -1056,7 +1055,6 @@ static void remove_dquot_ref(struct super_block *sb, int type, }spin_unlock (&dq_data_lock); } -spin_unlock (&sb->s_inode_list_lock);#ifdef CONFIG_QUOTA_DEBUG if (reserved) { printk(KERN_WARNING "VFS (%s): Writes happened after quota"
fs/super.c +4 -3
@@ -164,6 +164,7 @@ static void destroy_super(struct super_block *s) {list_lru_destroy (&s->s_dentry_lru);list_lru_destroy (&s->s_inode_lru); +free_dlock_list_heads (&s->s_inodes);security_sb_free (s);WARN_ON (!list_empty (&s->s_mounts));put_user_ns (s->s_user_ns);
@@ -210,11 +211,11 @@ static struct super_block *alloc_super(struct file_system_type *type, int flags,INIT_HLIST_NODE (&s->s_instances);INIT_HLIST_BL_HEAD (&s->s_anon);mutex_init (&s->s_sync_lock); -INIT_LIST_HEAD (&s->s_inodes); -spin_lock_init (&s->s_inode_list_lock);INIT_LIST_HEAD (&s->s_inodes_wb);spin_lock_init (&s->s_inode_wblist_lock); +if (alloc_dlock_list_heads (&s->s_inodes)) + goto fail;if (list_lru_init_memcg (&s->s_dentry_lru)) goto fail;if (list_lru_init_memcg (&s->s_inode_lru))
@@ -434,7 +435,7 @@ void generic_shutdown_super(struct super_block *sb)if (sop->put_super) sop->put_super (sb); -if (!list_empty (&sb->s_inodes)) { +if (!dlock_lists_empty (&sb->s_inodes)) {printk ("VFS: Busy inodes after unmount of %s. " "Self-destruct in 5 seconds. Have a nice day...\n" , sb->s_id);
include/linux/fs.h +4 -4
@@ -34,6 +34,7 @@#include <linux/delayed_call.h> #include <linux/uuid.h> #include <linux/errseq.h> +#include <linux/dlock-list.h> #include <asm/byteorder.h> #include <uapi/linux/fs.h>
@@ -632,7 +633,7 @@ struct inode {u16 i_wb_frn_history;#endif struct list_head i_lru;/* inode LRU list */ -struct list_head i_sb_list; +struct dlock_list_node i_sb_list;struct list_head i_wb_list;/* backing dev writeback list */ union {struct hlist_head i_dentry;
@@ -1434,9 +1435,8 @@ struct super_block {*/ int s_stack_depth; -/* s_inode_list_lock protects s_inodes */ -spinlock_t s_inode_list_lock____cacheline_aligned_in_smp ; -struct list_head s_inodes;/* all inodes */ +/* The internal per-list locks protect s_inodes */ +struct dlock_list_heads s_inodes;/* all inodes */ spinlock_t s_inode_wblist_lock;struct list_head s_inodes_wb;/* writeback inodes */
Signature · 1 line
1.8.3.1
PATCH v8 4/6 lib/dlock-list: Make sibling CPUs share the same linked list
In reply to Waiman LongThe dlock list needs one list for each of the CPUs available. However, for sibling CPUs, they are sharing the L2 and probably L1 caches too. As a result, there is not much to gain in term of avoiding cacheline contention while increasing the cacheline footprint of the L1/L2 caches as separate lists may need to be in the cache.
This patch makes all the sibling CPUs share the same list, thus reducing the number of lists that need to be maintained in each dlock list without having any noticeable impact on performance. It also improves dlock list iteration performance as fewer lists need to be iterated.
--- lib/dlock-list.c | 74 ++++++++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 59 insertions(+), 15 deletions(-)
lib/dlock-list.c +59 -15
@@ -25,31 +25,65 @@* The distributed and locked list is a distributed set of lists each of * which is protected by its own spinlock, but acts like a single * consolidated list to the callers. For scaling purpose, the number of -* lists used is equal to the number of possible CPUs in the system to -* minimize contention. +* lists used is equal to the number of possible cores in the system to +* minimize contention. All threads of the same CPU core will share the +* same list. * -* However, it is possible that individual CPU numbers may be equal to -* or greater than the number of possible CPUs when there are holes in -* the CPU number list. As a result, we need to map the CPU number to a -* list index. +* We need to map each CPU number to a list index. */ static DEFINE_PER_CPU_READ_MOSTLY(int, cpu2idx); +static int nr_dlock_lists__read_mostly ;/* -* Initialize cpu2idx mapping table +* Initialize cpu2idx mapping table & nr_dlock_lists. * * It is possible that a dlock-list can be allocated before the cpu2idx is * initialized. In this case, all the cpus are mapped to the first entry * before initialization. * +* All the sibling CPUs of a sibling group will map to the same dlock list so +* as to reduce the number of dlock lists to be maintained while minimizing +* cacheline contention. +* +* As the sibling masks are set up in the core initcall phase, this function +* has to be done in the postcore phase to get the right data. */ static int __init cpu2idx_init (void ) {int idx, cpu; +struct cpumask *sibling_mask; +static struct cpumask mask__initdata ; +cpumask_clear (&mask); idx =0 ; -for_each_possible_cpu (cpu) -per_cpu (cpu2idx, cpu) = idx++; +for_each_possible_cpu (cpu) { +int scpu; + +if (cpumask_test_cpu (cpu, &mask)) +continue ; +per_cpu (cpu2idx, cpu) = idx; +cpumask_set_cpu (cpu, &mask); + + sibling_mask =topology_sibling_cpumask (cpu); +if (sibling_mask) { +for_each_cpu (scpu, sibling_mask) { +per_cpu (cpu2idx, scpu) = idx; +cpumask_set_cpu (scpu, &mask); + } + } + idx++; + } + +/* +* nr_dlock_lists can only be set after cpu2idx is properly +* initialized. +*/ +smp_mb (); + nr_dlock_lists = idx; +WARN_ON (nr_dlock_lists > nr_cpu_ids); + +pr_info ("dlock-list: %d head entries per dlock list.\n" , + nr_dlock_lists);return 0 ; }postcore_initcall (cpu2idx_init);
@@ -67,19 +101,23 @@ static int __init cpu2idx_init(void)* * Dynamically allocated locks need to have their own special lock class * to avoid lockdep warning. +* +* Since nr_dlock_lists will always be <= nr_cpu_ids, having more lists +* than necessary allocated is not a problem other than some wasted memory. +* The extra lists will not be ever used as all the cpu2idx entries will be +* 0 before initialization. */ int __alloc_dlock_list_heads (struct dlock_list_heads *dlist,struct lock_class_key *key) { -int idx; +int idx, cnt = nr_dlock_lists ? nr_dlock_lists : nr_cpu_ids; - dlist->heads =kcalloc (nr_cpu_ids,sizeof (struct dlock_list_head ), -GFP_KERNEL ); + dlist->heads =kcalloc (cnt,sizeof (struct dlock_list_head ),GFP_KERNEL );if (!dlist->heads)return -ENOMEM ; -for (idx =0 ; idx < nr_cpu_ids; idx++) { +for (idx =0 ; idx < cnt; idx++) {struct dlock_list_head *head = &dlist->heads[idx];INIT_LIST_HEAD (&head->list);
@@ -117,7 +155,10 @@ bool dlock_lists_empty(struct dlock_list_heads *dlist) {int idx; -for (idx =0 ; idx < nr_cpu_ids; idx++) +/* Shouldn't be called before nr_dlock_lists is initialized */ +WARN_ON_ONCE (!nr_dlock_lists); + +for (idx =0 ; idx < nr_dlock_lists; idx++)if (!list_empty (&dlist->heads[idx].list))return false;return true;
@@ -199,6 +240,9 @@ struct dlock_list_node *__dlock_list_next_list(struct dlock_list_iter *iter)struct dlock_list_node *next;struct dlock_list_head *head; +/* Shouldn't be called before nr_dlock_lists is initialized */ +WARN_ON_ONCE (!nr_dlock_lists); + restart:if (iter->entry) {spin_unlock (&iter->entry->lock);
@@ -209,7 +253,7 @@ struct dlock_list_node *__dlock_list_next_list(struct dlock_list_iter *iter)/* * Try next list */ -if (++iter->index >= nr_cpu_ids) +if (++iter->index >= nr_dlock_lists)return NULL ;/* All the entries iterated */ if (list_empty (&iter->head[iter->index].list))
Signature · 1 line
1.8.3.1
Re: [PATCH v8 4/6] lib/dlock-list: Make sibling CPUs share the same linked list
Quoted 6 lines · Waiman Long
The dlock list needs one list for each of the CPUs available. However, for sibling CPUs, they are sharing the L2 and probably L1 caches too. As a result, there is not much to gain in term of avoiding cacheline contention while increasing the cacheline footprint of the L1/L2 caches as separate lists may need to be in the cache.
Quoted 7 lines
This patch makes all the sibling CPUs share the same list, thus reducing the number of lists that need to be maintained in each dlock list without having any noticeable impact on performance. It also improves dlock list iteration performance as fewer lists need to be iterated.
Signed-off-by Waiman Long <[email protected]>
The patch looks good to me. You can add:
Honza
Quoted 146 lines
--- lib/dlock-list.c | 74 ++++++++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 59 insertions(+), 15 deletions(-)lib/dlock-list.c +59
-15@@ -25,31 +25,65 @@* The distributed and locked list is a distributed set of lists each of * which is protected by its own spinlock, but acts like a single * consolidated list to the callers. For scaling purpose, the number of -* lists used is equal to the number of possible CPUs in the system to -* minimize contention. +* lists used is equal to the number of possible cores in the system to +* minimize contention. All threads of the same CPU core will share the +* same list. * -* However, it is possible that individual CPU numbers may be equal to -* or greater than the number of possible CPUs when there are holes in -* the CPU number list. As a result, we need to map the CPU number to a -* list index. +* We need to map each CPU number to a list index. */ static DEFINE_PER_CPU_READ_MOSTLY(int, cpu2idx); +static int nr_dlock_lists__read_mostly ;/* -* Initialize cpu2idx mapping table +* Initialize cpu2idx mapping table & nr_dlock_lists. * * It is possible that a dlock-list can be allocated before the cpu2idx is * initialized. In this case, all the cpus are mapped to the first entry * before initialization. * +* All the sibling CPUs of a sibling group will map to the same dlock list so +* as to reduce the number of dlock lists to be maintained while minimizing +* cacheline contention. +* +* As the sibling masks are set up in the core initcall phase, this function +* has to be done in the postcore phase to get the right data. */ static int __init cpu2idx_init (void ) {int idx, cpu; +struct cpumask *sibling_mask; +static struct cpumask mask__initdata ; +cpumask_clear (&mask); idx =0 ; -for_each_possible_cpu (cpu) -per_cpu (cpu2idx, cpu) = idx++; +for_each_possible_cpu (cpu) { +int scpu; + +if (cpumask_test_cpu (cpu, &mask)) +continue ; +per_cpu (cpu2idx, cpu) = idx; +cpumask_set_cpu (cpu, &mask); + + sibling_mask =topology_sibling_cpumask (cpu); +if (sibling_mask) { +for_each_cpu (scpu, sibling_mask) { +per_cpu (cpu2idx, scpu) = idx; +cpumask_set_cpu (scpu, &mask); + } + } + idx++; + } + +/* +* nr_dlock_lists can only be set after cpu2idx is properly +* initialized. +*/ +smp_mb (); + nr_dlock_lists = idx; +WARN_ON (nr_dlock_lists > nr_cpu_ids); + +pr_info ("dlock-list: %d head entries per dlock list.\n" , + nr_dlock_lists);return 0 ; }postcore_initcall (cpu2idx_init);@@ -67,19 +101,23 @@ static int __init cpu2idx_init(void)* * Dynamically allocated locks need to have their own special lock class * to avoid lockdep warning. +* +* Since nr_dlock_lists will always be <= nr_cpu_ids, having more lists +* than necessary allocated is not a problem other than some wasted memory. +* The extra lists will not be ever used as all the cpu2idx entries will be +* 0 before initialization. */ int __alloc_dlock_list_heads (struct dlock_list_heads *dlist,struct lock_class_key *key) { -int idx; +int idx, cnt = nr_dlock_lists ? nr_dlock_lists : nr_cpu_ids; - dlist->heads =kcalloc (nr_cpu_ids,sizeof (struct dlock_list_head ), -GFP_KERNEL ); + dlist->heads =kcalloc (cnt,sizeof (struct dlock_list_head ),GFP_KERNEL );if (!dlist->heads)return -ENOMEM ; -for (idx =0 ; idx < nr_cpu_ids; idx++) { +for (idx =0 ; idx < cnt; idx++) {struct dlock_list_head *head = &dlist->heads[idx];INIT_LIST_HEAD (&head->list);@@ -117,7 +155,10 @@ bool dlock_lists_empty(struct dlock_list_heads *dlist) {int idx; -for (idx =0 ; idx < nr_cpu_ids; idx++) +/* Shouldn't be called before nr_dlock_lists is initialized */ +WARN_ON_ONCE (!nr_dlock_lists); + +for (idx =0 ; idx < nr_dlock_lists; idx++)if (!list_empty (&dlist->heads[idx].list))return false;return true;@@ -199,6 +240,9 @@ struct dlock_list_node *__dlock_list_next_list(struct dlock_list_iter *iter)struct dlock_list_node *next;struct dlock_list_head *head; +/* Shouldn't be called before nr_dlock_lists is initialized */ +WARN_ON_ONCE (!nr_dlock_lists); + restart:if (iter->entry) {spin_unlock (&iter->entry->lock);@@ -209,7 +253,7 @@ struct dlock_list_node *__dlock_list_next_list(struct dlock_list_iter *iter)/* * Try next list */ -if (++iter->index >= nr_cpu_ids) +if (++iter->index >= nr_dlock_lists)return NULL ;/* All the entries iterated */ if (list_empty (&iter->head[iter->index].list))Signature · 1 line
1.8.3.1
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
PATCH v8 5/6 lib/dlock-list: Enable faster lookup with hashing
In reply to Waiman LongInsertion and deletion is relatively cheap and mostly contention free for dlock-list. Lookup, on the other hand, can be rather costly because all the lists in a dlock-list will have to be iterated.
Currently dlock-list insertion is based on the cpu that the task is running on. So a given object can be inserted into any one of the lists depending on what the current cpu is.
This patch provides an alternative way of list selection. The caller can provide a object context which will be hashed to one of the list in a dlock-list. The object can then be added into that particular list. Lookup can be done by iterating elements in the provided list only instead of all the lists in a dlock-list.
The new APIs are:
struct dlock_list_head *dlock_list_hash(struct dlock_list_heads *, void *); void dlock_list_add(struct dlock_list_node *, struct dlock_list_head *);
--- include/linux/dlock-list.h | 9 ++++++++ lib/dlock-list.c | 51 +++++++++++++++++++++++++++++++++++++++------- 2 files changed, 53 insertions(+), 7 deletions(-)
include/linux/dlock-list.h +9 -0
@@ -133,6 +133,15 @@ extern void dlock_lists_add(struct dlock_list_node *node,extern void dlock_lists_del (struct dlock_list_node *node);/* +* Instead of individual list mapping by CPU number, it can be based on +* a given context to speed up loockup performance. +*/ +extern struct dlock_list_head *dlock_list_hash (struct dlock_list_heads *dlist, +void *context); +extern void dlock_list_add (struct dlock_list_node *node, +struct dlock_list_head *head); + +/* * Find the first entry of the next available list. */ extern struct dlock_list_node *
lib/dlock-list.c +44 -7
69 lines not on this page · raw message
Signature · 1 line
1.8.3.1
Jan Kara
maintainerRe: [PATCH v8 5/6] lib/dlock-list: Enable faster lookup with hashing
Quoted 14 lines · Waiman Long
Insertion and deletion is relatively cheap and mostly contention free for dlock-list. Lookup, on the other hand, can be rather costly because all the lists in a dlock-list will have to be iterated.
Currently dlock-list insertion is based on the cpu that the task is running on. So a given object can be inserted into any one of the lists depending on what the current cpu is.
This patch provides an alternative way of list selection. The caller can provide a object context which will be hashed to one of the list in a dlock-list. The object can then be added into that particular list. Lookup can be done by iterating elements in the provided list only instead of all the lists in a dlock-list.
Quoted 6 lines
The new APIs are:
struct
dlock_list_head*dlock_list_hash(structdlock_list_heads*, void *); voiddlock_list_add(struct dlock_list_node *, struct dlock_list_head *);Signed-off-by Waiman Long <[email protected]>
Hum, do we have any users for this API? And wouldn't they also need to control how many lists are allocated then?
Honza
Quoted 105 lines
--- include/linux/dlock-list.h | 9 ++++++++ lib/dlock-list.c | 51 +++++++++++++++++++++++++++++++++++++++------- 2 files changed, 53 insertions(+), 7 deletions(-)include/linux/dlock-list.h +9
-0@@ -133,6 +133,15 @@ extern void dlock_lists_add(struct dlock_list_node *node,extern void dlock_lists_del (struct dlock_list_node *node);/* +* Instead of individual list mapping by CPU number, it can be based on +* a given context to speed up loockup performance. +*/ +extern struct dlock_list_head *dlock_list_hash (struct dlock_list_heads *dlist, +void *context); +extern void dlock_list_add (struct dlock_list_node *node, +struct dlock_list_head *head); + +/* * Find the first entry of the next available list. */ extern struct dlock_list_node *lib/dlock-list.c +44
-7@@ -20,6 +20,7 @@#include <linux/lockdep.h> #include <linux/slab.h> #include <linux/cpumask.h> +#include <linux/jhash.h> /* * The distributed and locked list is a distributed set of lists each of @@ -166,6 +167,48 @@ bool dlock_lists_empty(struct dlock_list_heads *dlist)EXPORT_SYMBOL (dlock_lists_empty);/** +* dlock_list_hash - Hash the given context to a particular list +* @dlist: The dlock list +* @ctx : The context for hashing +*/ +struct dlock_list_head *dlock_list_hash (struct dlock_list_heads *dlist, +void *ctx) +{ +unsigned long val = (unsigned long )ctx; +u32 hash; + +if (unlikely (!nr_dlock_lists)) { +WARN_ON_ONCE (1 ); +return &dlist->heads[0 ]; + } +if (val < nr_dlock_lists) + hash = val; +else + hash =jhash2 ((u32 *)&ctx,sizeof (ctx)/sizeof (u32),0 ) + % nr_dlock_lists; +return &dlist->heads[hash]; +} +EXPORT_SYMBOL (dlock_list_hash); + +/** +* dlock_list_add - Add a node to a particular head of dlock list +* @node: The node to be added +* @head: The dlock list head where the node is to be added +*/ +void dlock_list_add (struct dlock_list_node *node, +struct dlock_list_head *head) +{ +/* +* There is no need to disable preemption +*/ +spin_lock (&head->lock); + node->head = head; +list_add (&node->list, &head->list); +spin_unlock (&head->lock); +} +EXPORT_SYMBOL (dlock_list_add); + +/** * dlock_lists_add - Adds a node to the given dlock list * @node : The node to be added * @dlist: The dlock list where the node is to be added @@ -178,13 +221,7 @@ void dlock_lists_add(struct dlock_list_node *node, {struct dlock_list_head *head = &dlist->heads[this_cpu_read (cpu2idx)]; -/* -* There is no need to disable preemption -*/ -spin_lock (&head->lock); - node->head = head; -list_add (&node->list, &head->list); -spin_unlock (&head->lock); +dlock_list_add (node, head); }EXPORT_SYMBOL (dlock_lists_add);Signature · 1 line
1.8.3.1
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Re: [PATCH v8 5/6] lib/dlock-list: Enable faster lookup with hashing
Quoted 15 lines · Jan Kara
Quoted 14 lines · Waiman Long
Insertion and deletion is relatively cheap and mostly contention free for dlock-list. Lookup, on the other hand, can be rather costly because all the lists in a dlock-list will have to be iterated.
Currently dlock-list insertion is based on the cpu that the task is running on. So a given object can be inserted into any one of the lists depending on what the current cpu is.
This patch provides an alternative way of list selection. The caller can provide a object context which will be hashed to one of the list in a dlock-list. The object can then be added into that particular list. Lookup can be done by iterating elements in the provided list only instead of all the lists in a dlock-list.
Quoted 8 lines
Quoted 6 lines
The new APIs are:
struct
dlock_list_head*dlock_list_hash(structdlock_list_heads*, void *); voiddlock_list_add(struct dlock_list_node *, struct dlock_list_head *);Signed-off-by Waiman Long <[email protected]>Hum, do we have any users for this API? And wouldn't they also need to control how many lists are allocated then?
This patch is supposed to be used by the epoll patch from Davidlohr. As he has retracted the patch, I can drop this patch also. The number of lists scale with the number of CPU cores in the system whether it is used one way or the others.
Cheers,
Longman
PATCH v8 6/6 lib/dlock-list: Add an IRQ-safe mode to be used in interrupt handler
In reply to Waiman LongTo enable the use of dlock-list in an interrupt handler, a new irqsafe mode can now be specified at dlock-list allocation time as an additional argument to alloc_dlock_list_heads(). With that mode specified, the spin_lock_irqsave/spin_unlock_irqrestore pair will be used instead of the regular lock and unlock calls.
--- fs/super.c | 2 +- include/linux/dlock-list.h | 22 +++++++++++++++++----- lib/dlock-list.c | 46 ++++++++++++++++++++++++++++++++-------------- 3 files changed, 50 insertions(+), 20 deletions(-)
fs/super.c +1 -1
@@ -214,7 +214,7 @@ static struct super_block *alloc_super(struct file_system_type *type, int flags,INIT_LIST_HEAD (&s->s_inodes_wb);spin_lock_init (&s->s_inode_wblist_lock); -if (alloc_dlock_list_heads (&s->s_inodes)) +if (alloc_dlock_list_heads (&s->s_inodes, false)) goto fail;if (list_lru_init_memcg (&s->s_dentry_lru)) goto fail;
include/linux/dlock-list.h +17 -5
@@ -32,6 +32,8 @@struct dlock_list_head {struct list_head list;spinlock_t lock; +int irqsafe;/* IRQ safe mode */ +unsigned long flags; }____cacheline_aligned_in_smp ;struct dlock_list_heads {
@@ -89,7 +91,12 @@ static inline void init_dlock_list_node(struct dlock_list_node *node)*/ static inline void dlock_list_unlock (struct dlock_list_iter *iter) { -spin_unlock (&iter->entry->lock); +struct dlock_list_head *h = iter->entry; + +if (h->irqsafe) +spin_unlock_irqrestore (&h->lock, h->flags); +else +spin_unlock (&h->lock); }/**
@@ -98,14 +105,19 @@ static inline void dlock_list_unlock(struct dlock_list_iter *iter)*/ static inline void dlock_list_relock (struct dlock_list_iter *iter) { -spin_lock (&iter->entry->lock); +struct dlock_list_head *h = iter->entry; + +if (h->irqsafe) +spin_lock_irqsave (&h->lock, h->flags); +else +spin_lock (&h->lock); }/* * Allocation and freeing of dlock list */ extern int __alloc_dlock_list_heads (struct dlock_list_heads *dlist, -struct lock_class_key *key); +int irqsafe,struct lock_class_key *key);extern void free_dlock_list_heads (struct dlock_list_heads *dlist);/**
@@ -113,10 +125,10 @@ extern int __alloc_dlock_list_heads(struct dlock_list_heads *dlist,* @dlist : Pointer to the dlock_list_heads structure to be initialized * Return : 0 if successful, -ENOMEM if memory allocation error */ -#define alloc_dlock_list_heads (dlist) \ +#define alloc_dlock_list_heads (dlist, irqsafe) \ ({ \ static struct lock_class_key _key; \ - __alloc_dlock_list_heads(dlist, &_key); \ + __alloc_dlock_list_heads(dlist, irqsafe, &_key); \ })/*
lib/dlock-list.c +32 -14
100 lines not on this page · raw message
Signature · 1 line
1.8.3.1
Re: [PATCH v8 6/6] lib/dlock-list: Add an IRQ-safe mode to be used in interrupt handler
I would drop this patch for being too ugly and if nothing else, for lack of users (epoll will no longer need dlock).
Thanks,
Davidlohr
Are you planning on sending a v9 with the discussed changes? afaict:
- Drop last two patches
- Fix tearing (WRITE/READ_ONCE())
- Reduce barrier usage for dlock_lists_empty() -- which I'll be sending you shortly.
Thanks,
Davidlohr
Quoted 119 lines · Waiman Long
v7->v8:
- Integrate the additional patches 8, 9 and 10 sent to fix issues in the original v7 patchset into patch 1 and adjust the other patches accordingly.
v6->v7:
- Fix outdated email address.
- Add a comment to patch 4 to explain allocation issue & fix a compilation problem with cpumask.
- Replace patch 6 with another one that adds an irqsafe mode argument inalloc_dlock_list_heads()instead of adding new APIs.
v5->v6:
- Rebased the patch to 4.14-rc3.
- Drop the fsnotify patch as it had been merged somehow.
- Add a new patch 5 with alternative way of selecting list by hashing instead of cpu #.
- Add a new patch 6 to proivde a set irq safe APIs to be used in interrupt context.
- Update the CPU to index mapping code.
v4->v5:
- Rebased the patch to 4.8-rc1 (changes tofs/fs-writeback.cwas dropped).
- Usekcalloc()instead ofpercpu_alloc()to allocate the dlock list heads structure as suggested by Christoph Lameter.
- Replaced patch 5 by another one that made sibling CPUs use the same dlock list head thus reducing the number of list heads that needed to be maintained.
v3->v4:
- As suggested by Al, encapsulate the dlock list mechanism into thedlist_for_each_entry()anddlist_for_each_entry_safe()which are the equivalent oflist_for_each_entry()andlist_for_each_entry_safe()for regular linked list. That simplifies the changes in the call sites that perform dlock list iterations.
- Add a new patch to make the percpu head structure cacheline aligned to prevent cacheline contention from disrupting the performance of nearby percpu variables.
v2->v3:
- Remove the 2 persubnode API patches.
- Merge__percputag patch 2 into patch 1.
- As suggested by Tejun Heo, restructure thedlock_list_headdata structure to hide the__percputag and rename some of the functions and structures.
- Move most of the code fromdlock_list.htodlock_list.cand export the symbols.
v1->v2:
- Add a set of simple per-subnode APIs that is between percpu and per-node in granularity.
- Make dlock list to use the per-subnode APIs so as to reduce the total number of separate linked list that needs to be managed and iterated.
- There is no change in patches 1-5.This patchset provides new APIs for a set of distributed locked lists (one/CPU core) to minimize lock and cacheline contention. Insertion and deletion to the list will be cheap and relatively contention free. Lookup, on the other hand, may be a bit more costly as there are multiple lists to iterate. This is not really a problem for the replacement of superblock's inode list by dlock list included in the patchset as lookup isn't needed.
For use cases that need to do lookup, the dlock list can also be treated as a set of hashed lists that scales with the number of CPU cores in the system.
Both patches 5 and 6 are added to support other use cases like epoll nested callbacks, for example, which could use the dlock-list to reduce lock contention problem.
Patch 1 introduces the dlock list. The list heads are allocated by
kcalloc()instead ofpercpu_alloc(). Each list head entry is cacheline aligned to minimize contention.Patch 2 replaces the use of
list_for_each_entry_safe()inevict_inodes()andinvalidate_inodes()bylist_for_each_entry().Patch 3 modifies the superblock and inode structures to use the dlock list. The corresponding functions that reference those structures are modified.
Patch 4 makes the sibling CPUs use the same dlock list head to reduce the number of list heads that need to be iterated.
Patch 5 enables alternative use case of as a set of hashed lists.
Patch 6 provides an irq safe mode specified at dlock-list allocation time so that it can be used within interrupt context.
Jan Kara (1):
vfs: Remove unnecessarylist_for_each_entry_safe()variantsWaiman Long (5):
lib/dlock-list: Distributed and lock-protected lists
vfs: Use dlock list for superblock's inode listlib/dlock-list: Make sibling CPUs share the same linked listlib/dlock-list: Enable faster lookup with hashinglib/dlock-list: Add an IRQ-safe mode to be used in interrupt handlerfs/block_dev.c | 9 +- fs/drop_caches.c | 9 +- fs/inode.c | 38 ++---- fs/notify/fsnotify.c | 9 +- fs/quota/dquot.c | 14 +- fs/super.c | 7 +- include/linux/dlock-list.h | 263 +++++++++++++++++++++++++++++++++++ include/linux/fs.h | 8 +- lib/Makefile | 2 +- lib/dlock-list.c | 333 +++++++++++++++++++++++++++++++++++++++++++++ 10 files changed, 638 insertions(+), 54 deletions(-)create mode 100644
include/linux/dlock-list.h
create mode 100644lib/dlock-list.cSignature · 1 line
1.8.3.1
Quoted 9 lines · Davidlohr Bueso
Are you planning on sending a v9 with the discussed changes? afaict:
- Drop last two patches
- Fix tearing (WRITE/READ_ONCE())
- Reduce barrier usage fordlock_lists_empty()-- which I'll be sending you shortly.Thanks,
Davidlohr
Yes, I am planning to do so when I have some free time as I am working on a high-priority task at the moment.
Regards,
Longman
Hi Waiman,
What's happened to this patchset? Any plans to repost a more recent version?
FYI, I just ran a workload that hit 60% CPU usage on sb inode list lock contention - a multithreaded bulkstat scan of an XFS filesystem with millions of inodes on SSDs. last time I ran this (about 18 months ago now!) I saw rates of about 600,000 inodes/s being scanned from userspace. The run I did earlier today made 300,000 inodes/s on the same 16p machine and was completely CPU bound....
Cheers,
Dave.
Quoted 120 lines · Waiman Long
v7->v8:
- Integrate the additional patches 8, 9 and 10 sent to fix issues in the original v7 patchset into patch 1 and adjust the other patches accordingly.
v6->v7:
- Fix outdated email address.
- Add a comment to patch 4 to explain allocation issue & fix a compilation problem with cpumask.
- Replace patch 6 with another one that adds an irqsafe mode argument inalloc_dlock_list_heads()instead of adding new APIs.
v5->v6:
- Rebased the patch to 4.14-rc3.
- Drop the fsnotify patch as it had been merged somehow.
- Add a new patch 5 with alternative way of selecting list by hashing instead of cpu #.
- Add a new patch 6 to proivde a set irq safe APIs to be used in interrupt context.
- Update the CPU to index mapping code.
v4->v5:
- Rebased the patch to 4.8-rc1 (changes tofs/fs-writeback.cwas dropped).
- Usekcalloc()instead ofpercpu_alloc()to allocate the dlock list heads structure as suggested by Christoph Lameter.
- Replaced patch 5 by another one that made sibling CPUs use the same dlock list head thus reducing the number of list heads that needed to be maintained.
v3->v4:
- As suggested by Al, encapsulate the dlock list mechanism into thedlist_for_each_entry()anddlist_for_each_entry_safe()which are the equivalent oflist_for_each_entry()andlist_for_each_entry_safe()for regular linked list. That simplifies the changes in the call sites that perform dlock list iterations.
- Add a new patch to make the percpu head structure cacheline aligned to prevent cacheline contention from disrupting the performance of nearby percpu variables.
v2->v3:
- Remove the 2 persubnode API patches.
- Merge__percputag patch 2 into patch 1.
- As suggested by Tejun Heo, restructure thedlock_list_headdata structure to hide the__percputag and rename some of the functions and structures.
- Move most of the code fromdlock_list.htodlock_list.cand export the symbols.
v1->v2:
- Add a set of simple per-subnode APIs that is between percpu and per-node in granularity.
- Make dlock list to use the per-subnode APIs so as to reduce the total number of separate linked list that needs to be managed and iterated.
- There is no change in patches 1-5.This patchset provides new APIs for a set of distributed locked lists (one/CPU core) to minimize lock and cacheline contention. Insertion and deletion to the list will be cheap and relatively contention free. Lookup, on the other hand, may be a bit more costly as there are multiple lists to iterate. This is not really a problem for the replacement of superblock's inode list by dlock list included in the patchset as lookup isn't needed.
For use cases that need to do lookup, the dlock list can also be treated as a set of hashed lists that scales with the number of CPU cores in the system.
Both patches 5 and 6 are added to support other use cases like epoll nested callbacks, for example, which could use the dlock-list to reduce lock contention problem.
Patch 1 introduces the dlock list. The list heads are allocated by
kcalloc()instead ofpercpu_alloc(). Each list head entry is cacheline aligned to minimize contention.Patch 2 replaces the use of
list_for_each_entry_safe()inevict_inodes()andinvalidate_inodes()bylist_for_each_entry().Patch 3 modifies the superblock and inode structures to use the dlock list. The corresponding functions that reference those structures are modified.
Patch 4 makes the sibling CPUs use the same dlock list head to reduce the number of list heads that need to be iterated.
Patch 5 enables alternative use case of as a set of hashed lists.
Patch 6 provides an irq safe mode specified at dlock-list allocation time so that it can be used within interrupt context.
Jan Kara (1):
vfs: Remove unnecessarylist_for_each_entry_safe()variantsWaiman Long (5):
lib/dlock-list: Distributed and lock-protected lists
vfs: Use dlock list for superblock's inode listlib/dlock-list: Make sibling CPUs share the same linked listlib/dlock-list: Enable faster lookup with hashinglib/dlock-list: Add an IRQ-safe mode to be used in interrupt handlerfs/block_dev.c | 9 +- fs/drop_caches.c | 9 +- fs/inode.c | 38 ++---- fs/notify/fsnotify.c | 9 +- fs/quota/dquot.c | 14 +- fs/super.c | 7 +- include/linux/dlock-list.h | 263 +++++++++++++++++++++++++++++++++++ include/linux/fs.h | 8 +- lib/Makefile | 2 +- lib/dlock-list.c | 333 +++++++++++++++++++++++++++++++++++++++++++++ 10 files changed, 638 insertions(+), 54 deletions(-) create mode 100644 include/linux/dlock-list.h create mode 100644 lib/dlock-list.cSignature · 1 line
1.8.3.1
Signature · 2 lines
Dave Chinner [email protected]
Quoted 12 lines · Dave Chinner
Hi Waiman,
What's happened to this patchset? Any plans to repost a more recent version?
FYI, I just ran a workload that hit 60% CPU usage on sb inode list lock contention - a multithreaded bulkstat scan of an XFS filesystem with millions of inodes on SSDs. last time I ran this (about 18 months ago now!) I saw rates of about 600,000 inodes/s being scanned from userspace. The run I did earlier today made 300,000 inodes/s on the same 16p machine and was completely CPU bound....
Quoted 3 lines
Cheers,
Dave.
I was planning to repost the patchset with the latest change last November and then Meltdown/Spectre happened. I was drafted into backporting fixes to RHEL6. Hopefully, I can finish up the work in early March and work on my upstream patches again.
Cheers,
Longman