diff mbox

[PATCHv6,1/3] rwlock: Add per-cpu reader-writer lock infrastructure

Message ID 1453470107-27861-2-git-send-email-malcolm.crossley@citrix.com
State New, archived
Headers show

Commit Message

Malcolm Crossley Jan. 22, 2016, 1:41 p.m. UTC
Per-cpu read-write locks allow for the fast path read case to have
low overhead by only setting/clearing a per-cpu variable for using
the read lock. The per-cpu read fast path also avoids locked
compare swap operations which can be particularly slow on coherent
multi-socket systems, particularly if there is heavy usage of the
read lock itself.

The per-cpu reader-writer lock uses a local variable to control
the read lock fast path. This allows a writer to disable the fast
path and ensures the readers switch to using the underlying
read-write lock implementation instead of the per-cpu variable.

Once the writer has taken the write lock and disabled the fast path,
it must poll the per-cpu variable for all CPU's which have entered
the critical section for the specific read-write lock the writer is
attempting to take. This design allows for a single per-cpu variable
to be used for read/write locks belonging to seperate data structures.
If a two or more different per-cpu read lock(s) are taken
simultaneously then the per-cpu data structure is not used and the
implementation takes the read lock of the underlying read-write lock,
this behaviour is equivalent to the slow path in terms of performance.
The per-cpu rwlock is not recursion safe for taking the per-cpu
read lock because there is no recursion count variable, this is
functionally equivalent to standard spin locks.

Slow path readers which are unblocked, set the per-cpu variable and
drop the read lock. This simplifies the implementation and allows
for fairness in the underlying read-write lock to be taken
advantage of.

There is more overhead on the per-cpu write lock path due to checking
each CPUs fast path per-cpu variable but this overhead is likely be
hidden by the required delay of waiting for readers to exit the
critical section. The loop is optimised to only iterate over
the per-cpu data of active readers of the rwlock. The cpumask_t for
tracking the active readers is stored in a single per-cpu data
location and thus the write lock is not pre-emption safe. Therefore
the per-cpu write lock can only be used with interrupts disabled.

Signed-off-by: Malcolm Crossley <malcolm.crossley@citrix.com>
--
Changes since v5:
- Fix compilation on ARM
Changes since v4:
- Use static inlines for the percpu_owner check
Changes since v3:
- Fix the ASSERTS for the percpu_owner check
Changes since v2:
- Remove stray hard tabs
- Added owner field to percpu_rwlock_t for debug builds. This allows
  for ASSERTs to be added which verify the correct global percpu
  structure is used for the local initialised percpu_rwlock lock
Changes since v1:
- Removed restriction on taking two or more different percpu rw
locks simultaneously
- Moved fast-path/slow-path barrier to be per lock instead of global
- Created seperate percpu_rwlock_t type and added macros to
initialise new type
- Added helper macros for using the percpu rwlock itself
- Moved active_readers cpumask off the stack and into a percpu
  variable
---
 xen/common/spinlock.c        |  45 +++++++++++++++++
 xen/include/asm-arm/percpu.h |   5 ++
 xen/include/asm-x86/percpu.h |   6 +++
 xen/include/xen/percpu.h     |   4 ++
 xen/include/xen/spinlock.h   | 116 +++++++++++++++++++++++++++++++++++++++++++
 5 files changed, 176 insertions(+)

Comments

Ian Campbell Jan. 22, 2016, 1:54 p.m. UTC | #1
On Fri, 2016-01-22 at 13:41 +0000, Malcolm Crossley wrote:

> Changes since v5:
> - Fix compilation on ARM

This was the removal of some spurious "&", I think?

Acked-by: Ian Campbell <ian.campbell@citrix.com>

Thanks for catching this!
Malcolm Crossley Jan. 22, 2016, 2:16 p.m. UTC | #2
On 22/01/16 13:54, Ian Campbell wrote:
> On Fri, 2016-01-22 at 13:41 +0000, Malcolm Crossley wrote:
>>  
>> Changes since v5:
>> - Fix compilation on ARM
> 
> This was the removal of some spurious "&", I think?

Yeah, I forgot to keep the macro's in sync. ARM also needed the xen/percpu.h header file to be
explictly included into spinlock.h.

> 
> Acked-by: Ian Campbell <ian.campbell@citrix.com>
> 
> Thanks for catching this!

Sorry for not build testing before on ARM. Building the hypervisor itself using a prebuilt linaro
toolchain is actually very easy (no chroot required).

Do you think it's worth documenting this? So that at least hypervisor build failures are caught.

Malcolm
Ian Campbell Jan. 22, 2016, 2:22 p.m. UTC | #3
On Fri, 2016-01-22 at 14:16 +0000, Malcolm Crossley wrote:
> On 22/01/16 13:54, Ian Campbell wrote:
> > On Fri, 2016-01-22 at 13:41 +0000, Malcolm Crossley wrote:
> > >  
> > > Changes since v5:
> > > - Fix compilation on ARM
> > 
> > This was the removal of some spurious "&", I think?
> 
> Yeah, I forgot to keep the macro's in sync. ARM also needed the
> xen/percpu.h header file to be
> explictly included into spinlock.h.
> 
> > 
> > Acked-by: Ian Campbell <ian.campbell@citrix.com>
> > 
> > Thanks for catching this!
> 
> Sorry for not build testing before on ARM.

No problem, some people never remember at all, so v5 isn't too bad ;-)

>  Building the hypervisor itself using a prebuilt linaro
> toolchain is actually very easy (no chroot required).

Indeed.

> Do you think it's worth documenting this? So that at least hypervisor
> build failures are caught.

I think it's covered by
http://wiki.xen.org/wiki/Xen_ARM_with_Virtualization_Extensions#Cross_Compiling

or do you mean something more?

Ian.
Ross Lagerwall Jan. 22, 2016, 2:25 p.m. UTC | #4
On 01/22/2016 02:16 PM, Malcolm Crossley wrote:
> On 22/01/16 13:54, Ian Campbell wrote:
>> On Fri, 2016-01-22 at 13:41 +0000, Malcolm Crossley wrote:
>>>
>>> Changes since v5:
>>> - Fix compilation on ARM
>>
>> This was the removal of some spurious "&", I think?
>
> Yeah, I forgot to keep the macro's in sync. ARM also needed the xen/percpu.h header file to be
> explictly included into spinlock.h.
>
>>
>> Acked-by: Ian Campbell <ian.campbell@citrix.com>
>>
>> Thanks for catching this!
>
> Sorry for not build testing before on ARM. Building the hypervisor itself using a prebuilt linaro
> toolchain is actually very easy (no chroot required).
>
> Do you think it's worth documenting this? So that at least hypervisor build failures are caught.
>

This is already documented (briefly) here:
http://wiki.xen.org/wiki/Xen_ARM_with_Virtualization_Extensions#Cross_Compiling
Malcolm Crossley Jan. 22, 2016, 2:30 p.m. UTC | #5
On 22/01/16 14:22, Ian Campbell wrote:
> On Fri, 2016-01-22 at 14:16 +0000, Malcolm Crossley wrote:
>> On 22/01/16 13:54, Ian Campbell wrote:
>>> On Fri, 2016-01-22 at 13:41 +0000, Malcolm Crossley wrote:
>>>>  
>>>> Changes since v5:
>>>> - Fix compilation on ARM
>>>
>>> This was the removal of some spurious "&", I think?
>>
>> Yeah, I forgot to keep the macro's in sync. ARM also needed the
>> xen/percpu.h header file to be
>> explictly included into spinlock.h.
>>
>>>
>>> Acked-by: Ian Campbell <ian.campbell@citrix.com>
>>>
>>> Thanks for catching this!
>>
>> Sorry for not build testing before on ARM.
> 
> No problem, some people never remember at all, so v5 isn't too bad ;-)
> 
>>  Building the hypervisor itself using a prebuilt linaro
>> toolchain is actually very easy (no chroot required).
> 
> Indeed.
> 
>> Do you think it's worth documenting this? So that at least hypervisor
>> build failures are caught.
> 
> I think it's covered by
> http://wiki.xen.org/wiki/Xen_ARM_with_Virtualization_Extensions#Cross_Compiling

Yeah that section covers it. I came across the toolstack page first and didn't check the third link
down in google :)

https://www.google.co.uk/search?q=xen+cross+compilation

Maybe there should be comment in the toolstack page linking back to the simpler hypervisor only steps :)

> 
> or do you mean something more?
> 
> Ian.
>
Ian Campbell Jan. 22, 2016, 2:45 p.m. UTC | #6
On Fri, 2016-01-22 at 14:30 +0000, Malcolm Crossley wrote:
> On 22/01/16 14:22, Ian Campbell wrote:
> > On Fri, 2016-01-22 at 14:16 +0000, Malcolm Crossley wrote:
> > > On 22/01/16 13:54, Ian Campbell wrote:
> > > > On Fri, 2016-01-22 at 13:41 +0000, Malcolm Crossley wrote:
> > > > >  
> > > > > Changes since v5:
> > > > > - Fix compilation on ARM
> > > > 
> > > > This was the removal of some spurious "&", I think?
> > > 
> > > Yeah, I forgot to keep the macro's in sync. ARM also needed the
> > > xen/percpu.h header file to be
> > > explictly included into spinlock.h.
> > > 
> > > > 
> > > > Acked-by: Ian Campbell <ian.campbell@citrix.com>
> > > > 
> > > > Thanks for catching this!
> > > 
> > > Sorry for not build testing before on ARM.
> > 
> > No problem, some people never remember at all, so v5 isn't too bad ;-)
> > 
> > >  Building the hypervisor itself using a prebuilt linaro
> > > toolchain is actually very easy (no chroot required).
> > 
> > Indeed.
> > 
> > > Do you think it's worth documenting this? So that at least hypervisor
> > > build failures are caught.
> > 
> > I think it's covered by
> > http://wiki.xen.org/wiki/Xen_ARM_with_Virtualization_Extensions#Cross_C
> > ompiling
> 
> Yeah that section covers it. I came across the toolstack page first and
> didn't check the third link
> down in google :)
> 
> https://www.google.co.uk/search?q=xen+cross+compilation
> 
> Maybe there should be comment in the toolstack page linking back to the
> simpler hypervisor only steps :)

Good idea, done.
diff mbox

Patch

diff --git a/xen/common/spinlock.c b/xen/common/spinlock.c
index 7b0cf6c..bab1f95 100644
--- a/xen/common/spinlock.c
+++ b/xen/common/spinlock.c
@@ -10,6 +10,8 @@ 
 #include <asm/processor.h>
 #include <asm/atomic.h>
 
+static DEFINE_PER_CPU(cpumask_t, percpu_rwlock_readers);
+
 #ifndef NDEBUG
 
 static atomic_t spin_debug __read_mostly = ATOMIC_INIT(0);
@@ -492,6 +494,49 @@  int _rw_is_write_locked(rwlock_t *lock)
     return (lock->lock == RW_WRITE_FLAG); /* writer in critical section? */
 }
 
+void _percpu_write_lock(percpu_rwlock_t **per_cpudata,
+                percpu_rwlock_t *percpu_rwlock)
+{
+    unsigned int cpu;
+    cpumask_t *rwlock_readers = &this_cpu(percpu_rwlock_readers);
+
+    /* Validate the correct per_cpudata variable has been provided. */
+    _percpu_rwlock_owner_check(per_cpudata, percpu_rwlock);
+
+    /* 
+     * First take the write lock to protect against other writers or slow 
+     * path readers.
+     */
+    write_lock(&percpu_rwlock->rwlock);
+
+    /* Now set the global variable so that readers start using read_lock. */
+    percpu_rwlock->writer_activating = 1;
+    smp_mb();
+
+    /* Using a per cpu cpumask is only safe if there is no nesting. */
+    ASSERT(!in_irq());
+    cpumask_copy(rwlock_readers, &cpu_online_map);
+
+    /* Check if there are any percpu readers in progress on this rwlock. */
+    for ( ; ; )
+    {
+        for_each_cpu(cpu, rwlock_readers)
+        {
+            /* 
+             * Remove any percpu readers not contending on this rwlock
+             * from our check mask.
+             */
+            if ( per_cpu_ptr(per_cpudata, cpu) != percpu_rwlock )
+                __cpumask_clear_cpu(cpu, rwlock_readers);
+        }
+        /* Check if we've cleared all percpu readers from check mask. */
+        if ( cpumask_empty(rwlock_readers) )
+            break;
+        /* Give the coherency fabric a break. */
+        cpu_relax();
+    };
+}
+
 #ifdef LOCK_PROFILE
 
 struct lock_profile_anc {
diff --git a/xen/include/asm-arm/percpu.h b/xen/include/asm-arm/percpu.h
index 71e7649..7968532 100644
--- a/xen/include/asm-arm/percpu.h
+++ b/xen/include/asm-arm/percpu.h
@@ -27,6 +27,11 @@  void percpu_init_areas(void);
 #define __get_cpu_var(var) \
     (*RELOC_HIDE(&per_cpu__##var, READ_SYSREG(TPIDR_EL2)))
 
+#define per_cpu_ptr(var, cpu)  \
+    (*RELOC_HIDE(var, __per_cpu_offset[cpu]))
+#define __get_cpu_ptr(var) \
+    (*RELOC_HIDE(var, READ_SYSREG(TPIDR_EL2)))
+
 #define DECLARE_PER_CPU(type, name) extern __typeof__(type) per_cpu__##name
 
 DECLARE_PER_CPU(unsigned int, cpu_id);
diff --git a/xen/include/asm-x86/percpu.h b/xen/include/asm-x86/percpu.h
index 604ff0d..51562b9 100644
--- a/xen/include/asm-x86/percpu.h
+++ b/xen/include/asm-x86/percpu.h
@@ -20,4 +20,10 @@  void percpu_init_areas(void);
 
 #define DECLARE_PER_CPU(type, name) extern __typeof__(type) per_cpu__##name
 
+#define __get_cpu_ptr(var) \
+    (*RELOC_HIDE(var, get_cpu_info()->per_cpu_offset))
+
+#define per_cpu_ptr(var, cpu)  \
+    (*RELOC_HIDE(var, __per_cpu_offset[cpu]))
+
 #endif /* __X86_PERCPU_H__ */
diff --git a/xen/include/xen/percpu.h b/xen/include/xen/percpu.h
index abe0b11..c896863 100644
--- a/xen/include/xen/percpu.h
+++ b/xen/include/xen/percpu.h
@@ -16,6 +16,10 @@ 
 /* Preferred on Xen. Also see arch-defined per_cpu(). */
 #define this_cpu(var)    __get_cpu_var(var)
 
+#define this_cpu_ptr(ptr)    __get_cpu_ptr(ptr)
+
+#define get_per_cpu_var(var)  (per_cpu__##var)
+
 /* Linux compatibility. */
 #define get_cpu_var(var) this_cpu(var)
 #define put_cpu_var(var)
diff --git a/xen/include/xen/spinlock.h b/xen/include/xen/spinlock.h
index 9555c53..8b2590f 100644
--- a/xen/include/xen/spinlock.h
+++ b/xen/include/xen/spinlock.h
@@ -3,6 +3,8 @@ 
 
 #include <asm/system.h>
 #include <asm/spinlock.h>
+#include <asm/types.h>
+#include <xen/percpu.h>
 
 #ifndef NDEBUG
 struct lock_debug {
@@ -263,4 +265,118 @@  int _rw_is_write_locked(rwlock_t *lock);
 #define rw_is_locked(l)               _rw_is_locked(l)
 #define rw_is_write_locked(l)         _rw_is_write_locked(l)
 
+typedef struct percpu_rwlock percpu_rwlock_t;
+
+struct percpu_rwlock {
+    rwlock_t            rwlock;
+    bool_t              writer_activating;
+#ifndef NDEBUG
+    percpu_rwlock_t     **percpu_owner;
+#endif
+};
+
+#ifndef NDEBUG
+#define PERCPU_RW_LOCK_UNLOCKED(owner) { RW_LOCK_UNLOCKED, 0, owner }
+static inline void _percpu_rwlock_owner_check(percpu_rwlock_t **per_cpudata,
+                                         percpu_rwlock_t *percpu_rwlock)
+{
+    ASSERT(per_cpudata == percpu_rwlock->percpu_owner);
+}
+#else
+#define PERCPU_RW_LOCK_UNLOCKED(owner) { RW_LOCK_UNLOCKED, 0 }
+#define _percpu_rwlock_owner_check(data, lock) ((void)0)
+#endif
+
+#define DEFINE_PERCPU_RWLOCK_RESOURCE(l, owner) \
+    percpu_rwlock_t l = PERCPU_RW_LOCK_UNLOCKED(&get_per_cpu_var(owner))
+#define percpu_rwlock_resource_init(l, owner) \
+    (*(l) = (percpu_rwlock_t)PERCPU_RW_LOCK_UNLOCKED(&get_per_cpu_var(owner)))
+
+static inline void _percpu_read_lock(percpu_rwlock_t **per_cpudata,
+                                         percpu_rwlock_t *percpu_rwlock)
+{
+    /* Validate the correct per_cpudata variable has been provided. */
+    _percpu_rwlock_owner_check(per_cpudata, percpu_rwlock);
+
+    /* We cannot support recursion on the same lock. */
+    ASSERT(this_cpu_ptr(per_cpudata) != percpu_rwlock);
+    /* 
+     * Detect using a second percpu_rwlock_t simulatenously and fallback
+     * to standard read_lock.
+     */
+    if ( unlikely(this_cpu_ptr(per_cpudata) != NULL ) )
+    {
+        read_lock(&percpu_rwlock->rwlock);
+        return;
+    }
+
+    /* Indicate this cpu is reading. */
+    this_cpu_ptr(per_cpudata) = percpu_rwlock;
+    smp_mb();
+    /* Check if a writer is waiting. */
+    if ( unlikely(percpu_rwlock->writer_activating) )
+    {
+        /* Let the waiting writer know we aren't holding the lock. */
+        this_cpu_ptr(per_cpudata) = NULL;
+        /* Wait using the read lock to keep the lock fair. */
+        read_lock(&percpu_rwlock->rwlock);
+        /* Set the per CPU data again and continue. */
+        this_cpu_ptr(per_cpudata) = percpu_rwlock;
+        /* Drop the read lock because we don't need it anymore. */
+        read_unlock(&percpu_rwlock->rwlock);
+    }
+}
+
+static inline void _percpu_read_unlock(percpu_rwlock_t **per_cpudata,
+                percpu_rwlock_t *percpu_rwlock)
+{
+    /* Validate the correct per_cpudata variable has been provided. */
+    _percpu_rwlock_owner_check(per_cpudata, percpu_rwlock);
+
+    /* Verify the read lock was taken for this lock */
+    ASSERT(this_cpu_ptr(per_cpudata) != NULL);
+    /* 
+     * Detect using a second percpu_rwlock_t simulatenously and fallback
+     * to standard read_unlock.
+     */
+    if ( unlikely(this_cpu_ptr(per_cpudata) != percpu_rwlock ) )
+    {
+        read_unlock(&percpu_rwlock->rwlock);
+        return;
+    }
+    this_cpu_ptr(per_cpudata) = NULL;
+    smp_wmb();
+}
+
+/* Don't inline percpu write lock as it's a complex function. */
+void _percpu_write_lock(percpu_rwlock_t **per_cpudata,
+                        percpu_rwlock_t *percpu_rwlock);
+
+static inline void _percpu_write_unlock(percpu_rwlock_t **per_cpudata,
+                percpu_rwlock_t *percpu_rwlock)
+{
+    /* Validate the correct per_cpudata variable has been provided. */
+    _percpu_rwlock_owner_check(per_cpudata, percpu_rwlock);
+
+    ASSERT(percpu_rwlock->writer_activating);
+    percpu_rwlock->writer_activating = 0;
+    write_unlock(&percpu_rwlock->rwlock);
+}
+
+#define percpu_rw_is_write_locked(l)         _rw_is_write_locked(&((l)->rwlock))
+
+#define percpu_read_lock(percpu, lock) \
+    _percpu_read_lock(&get_per_cpu_var(percpu), lock)
+#define percpu_read_unlock(percpu, lock) \
+    _percpu_read_unlock(&get_per_cpu_var(percpu), lock)
+#define percpu_write_lock(percpu, lock) \
+    _percpu_write_lock(&get_per_cpu_var(percpu), lock)
+#define percpu_write_unlock(percpu, lock) \
+    _percpu_write_unlock(&get_per_cpu_var(percpu), lock)
+
+#define DEFINE_PERCPU_RWLOCK_GLOBAL(name) DEFINE_PER_CPU(percpu_rwlock_t *, \
+                                                         name)
+#define DECLARE_PERCPU_RWLOCK_GLOBAL(name) DECLARE_PER_CPU(percpu_rwlock_t *, \
+                                                         name)
+
 #endif /* __SPINLOCK_H__ */