Auto-queued ticketlock

arch/x86/include/asm/spinlock_types.h +8 -2

@@ -7,12 +7,18 @@
 
 #include <linux/types.h>
 
-#if (CONFIG_NR_CPUS < 256)
+#if (CONFIG_NR_CPUS < 128)
 typedef u8  __ticket_t;
 typedef u16 __ticketpair_t;
-#else
+#define TICKET_T_CMP_GE(a, b) (UCHAR_MAX / 2 >= (unsigned char)((a) - (b)))
+#elif (CONFIG_NR_CPUS < 32768)
 typedef u16 __ticket_t;
 typedef u32 __ticketpair_t;
+#define TICKET_T_CMP_GE(a, b) (USHRT_MAX / 2 >= (unsigned short)((a) - (b)))
+#else
+typedef u32 __ticket_t;
+typedef u64 __ticketpair_t;
+#define TICKET_T_CMP_GE(a, b) (UINT_MAX / 2 >= (unsigned int)((a) - (b)))
 #endif
 
 #define TICKET_SHIFT	(sizeof(__ticket_t) * 8)

arch/x86/include/asm/spinlock_types.h +3 -0

+			__ticket_t tail, head;
+#else /* #ifdef __BIG_ENDIAN__ */
 			__ticket_t head, tail;
+#endif /* #else #ifdef __BIG_ENDIAN__ */
 		} tickets;
 	};
 } arch_spinlock_t;

Quoted 22 lines · Paul E. McKenney

arch/x86/include/asm/spinlock_types.h +8 -2

@@ -7,12 +7,18 @@
 
 #include <linux/types.h>
 
-#if (CONFIG_NR_CPUS < 256)
+#if (CONFIG_NR_CPUS < 128)
 typedef u8  __ticket_t;
 typedef u16 __ticketpair_t;
-#else
+#define TICKET_T_CMP_GE(a, b) (UCHAR_MAX / 2 >= (unsigned char)((a) - (b)))
+#elif (CONFIG_NR_CPUS < 32768)
 typedef u16 __ticket_t;
 typedef u32 __ticketpair_t;
+#define TICKET_T_CMP_GE(a, b) (USHRT_MAX / 2 >= (unsigned short)((a) - (b)))
+#else
+typedef u32 __ticket_t;
+typedef u64 __ticketpair_t;
+#define TICKET_T_CMP_GE(a, b) (UINT_MAX / 2 >= (unsigned int)((a) - (b)))
 #endif
 

arch/x86/include/asm/spinlock_types.h typedef struct arch_spinlock { · line 30

Quoted 6 lines

arch/x86/include/asm/spinlock_types.h +1 -0

 #define TICKET_SHIFT	(sizeof(__ticket_t) * 8)

@@ -21,7 +27,11 @@ typedef struct arch_spinlock {
 	union {
 		__ticketpair_t head_tail;
 		struct __raw_tickets {
+#ifdef __BIG_ENDIAN__

Is there such a thing as a BIG_ENDIAN x86 box? This is in arch/x86/include/asm/spinlock_types.h

-- Steve

Quoted 7 lines

arch/x86/include/asm/spinlock_types.h +3 -0

+			__ticket_t tail, head;
+#else /* #ifdef __BIG_ENDIAN__ */
 			__ticket_t head, tail;
+#endif /* #else #ifdef __BIG_ENDIAN__ */
 		} tickets;
 	};
 } arch_spinlock_t;

Quoted 1 line · Paul E. McKenney

+#ifdef __BIG_ENDIAN__

Is there such a thing as a BIG_ENDIAN x86 box? This is in arch/x86/include/asm/spinlock_types.h

arch/x86/include/asm/spinlock.h +9 -0

+#else /* #ifndef CONFIG_TICKET_LOCK_QUEUED */
+
+bool tkt_spin_pass(arch_spinlock_t *ap, struct __raw_tickets inc);
+
+static __always_inline void __ticket_spin_lock(arch_spinlock_t *lock)
+{
+	register struct __raw_tickets inc = { .tail = 2 };
+
+	inc = xadd(&lock->tickets, inc);

Quoted 5 lines · Steven Rostedt

Quoted 1 line · Paul E. McKenney

+#ifdef __BIG_ENDIAN__

Is there such a thing as a BIG_ENDIAN x86 box? This is in arch/x86/include/asm/spinlock_types.h

That's just an habit for people who have been forced to deal with BE CPUs.

The sad thing is that BE CPUs have been designed by folks who blindly expanded BCD computing without understanding the hardware implications.

Unfortunately they managed to inflict BE to the network protocols which in turn manifested the only excuse of keeping the BE nonsense alive.

Quoted 14 lines · Paul E. McKenney

arch/x86/include/asm/spinlock.h +13 -0

+#else /* #ifndef CONFIG_TICKET_LOCK_QUEUED */
+
+bool tkt_spin_pass(arch_spinlock_t *ap, struct __raw_tickets inc);
+
+static __always_inline void __ticket_spin_lock(arch_spinlock_t *lock)
+{
+	register struct __raw_tickets inc = { .tail = 2 };
+
+	inc = xadd(&lock->tickets, inc);
+	for (;;) {
+		if (inc.head == inc.tail || tkt_spin_pass(lock, inc))
+			break;
+		inc.head = ACCESS_ONCE(lock->tickets.head);

arch/x86/include/asm/spinlock.h static __always_inline void __ticket_spin_lock(arch_spinlock_t *lock) · line 85

Quoted 6 lines

arch/x86/include/asm/spinlock.h +6 -0

+	}
+	barrier(); /* smp_mb() on Power or ARM. */
+}
+
+#endif /* #else #ifndef CONFIG_TICKET_LOCK_QUEUED */
+

To avoid the above code duplication, I would have this instead:

#ifdef CONFIG_TICKET_LOCK_QUEUED

bool tkt_spin_pass(arch_spinlock_t *ap, struct __raw_tickets inc); #define __TKT_SPIN_INC 2

#else

static inline bool tkt_spin_pass(arch_spinlock_t *ap, struct __raw_tickets inc)

{
	return false;
}

#define __TKT_SPIN_INC 1

#endif

static __always_inline void __ticket_spin_lock(arch_spinlock_t *lock)

{
	register struct __raw_tickets inc = { .tail = __TKT_SPIN_INC };

	inc = xadd(&lock->tickets, inc);

	for (;;) {
		if (inc.head == inc.tail || tkt_spin_pass(lock, inc))
			break;
		cpu_relax();
		inc.head = ACCESS_ONCE(lock->tickets.head);
	}
	barrier;	/* make sure nothing creeps before the lock is taken */
}

-- Steve

Breaking up locks is better than implementing high-contention locks, but if we must have high-contention locks, why not make them automatically switch between light-weight ticket locks at low contention and queued locks at high contention?

This commit therefore allows ticket locks to automatically switch between pure ticketlock and queued-lock operation as needed. If too many CPUs are spinning on a given ticket lock, a queue structure will be allocated and the lock will switch to queued-lock operation. When the lock becomes free, it will switch back into ticketlock operation. The low-order bit of the head counter is used to indicate that the lock is in queued mode, which forces an unconditional mismatch between the head and tail counters. This approach means that the common-case code path under conditions of low contention is very nearly that of a plain ticket lock.

A fixed number of queueing structures is statically allocated in an array. The ticket-lock address is used to hash into an initial element, but if that element is already in use, it moves to the next element. If the entire array is already in use, continue to spin in ticket mode.

This has been only lightly tested in the kernel, though a userspace implementation has survived substantial testing.

Signed-off-by Paul E. McKenney <[email protected]>

kernel/tktqlock.c new file +19 -0

+	if (head & 0x1)
+		tkt_q_do_wake(lock);
+}
+#endif /* #else #ifndef CONFIG_TICKET_LOCK_QUEUED */
 
+ */
+void tkt_q_do_wake(arch_spinlock_t *asp)
+{
+	struct tkt_q_head *tqhp;
+	struct tkt_q *tqp;
+
+	/* If the queue is still being set up, wait for it. */
+	while ((tqhp = tkt_q_find_head(asp)) == NULL)
+		cpu_relax();
+
+	for (;;) {
+
+		/* Find the first queue element. */
+		tqp = ACCESS_ONCE(tqhp->spin);
+		if (tqp != NULL)

Quoted 20 lines · Paul E. McKenney

Breaking up locks is better than implementing high-contention locks, but if we must have high-contention locks, why not make them automatically switch between light-weight ticket locks at low contention and queued locks at high contention?

This commit therefore allows ticket locks to automatically switch between pure ticketlock and queued-lock operation as needed. If too many CPUs are spinning on a given ticket lock, a queue structure will be allocated and the lock will switch to queued-lock operation. When the lock becomes free, it will switch back into ticketlock operation. The low-order bit of the head counter is used to indicate that the lock is in queued mode, which forces an unconditional mismatch between the head and tail counters. This approach means that the common-case code path under conditions of low contention is very nearly that of a plain ticket lock.

A fixed number of queueing structures is statically allocated in an array. The ticket-lock address is used to hash into an initial element, but if that element is already in use, it moves to the next element. If the entire array is already in use, continue to spin in ticket mode.

Quoted 4 lines

This has been only lightly tested in the kernel, though a userspace implementation has survived substantial testing.

Signed-off-by Paul E. McKenney <[email protected]>

This looks a great idea ;)

arch/x86/include/asm/spinlock.h static __always_inline int __ticket_spin_trylock(arch_spinlock_t *lock) · line 119

Quoted 6 lines

arch/x86/include/asm/spinlock.h +6 -0

+
+static __always_inline void __ticket_spin_unlock(arch_spinlock_t *lock)
+{
+	__ticket_t head = 2;
+
+	head = xadd(&lock->tickets.head, 2);

	head = xadd(&lock->tickets.head, head);

Quoted 24 lines

kernel/tktqlock.c new file +23 -0

+	if (head & 0x1)
+		tkt_q_do_wake(lock);
+}
+#endif /* #else #ifndef CONFIG_TICKET_LOCK_QUEUED */
 
+ */
+void tkt_q_do_wake(arch_spinlock_t *asp)
+{
+	struct tkt_q_head *tqhp;
+	struct tkt_q *tqp;
+
+	/* If the queue is still being set up, wait for it. */
+	while ((tqhp = tkt_q_find_head(asp)) == NULL)
+		cpu_relax();
+
+	for (;;) {
+
+		/* Find the first queue element. */
+		tqp = ACCESS_ONCE(tqhp->spin);
+		if (tqp != NULL)
+			break;  /* Element exists, hand off lock. */
+		if (tkt_q_try_unqueue(asp, tqhp))
+			return; /* No element, successfully removed queue. */
+		cpu_relax();

kernel/tktqlock.c line 148

Quoted 6 lines

kernel/tktqlock.c new file +6 -0

+	}
+	if (ACCESS_ONCE(tqhp->head_tkt) != -1)
+		ACCESS_ONCE(tqhp->head_tkt) = -1;
+	smp_mb(); /* Order pointer fetch and assignment against handoff. */
+	ACCESS_ONCE(tqp->cpu) = -1;
+}

EXPORT_SYMBOL(tkt_q_do_wake) ?

Hmm, unfortunately I lack time this week to fully read the patch !

kernel/tktqlock.c new file +12 -0

+{
+	int i;
+	int start;
+
+	start = i = tkt_q_hash(asp);
+	do
+		if (tkt_q_heads[i].ref == asp)
+			return &tkt_q_heads[i];
+	while ((i = tkt_q_next_slot(i)) != start);
+	return NULL;
+}
+

kernel/tktqlock.c line 77

Quoted 6 lines · Paul E. McKenney

kernel/tktqlock.c new file +6 -0

+/*
+ * Return a pointer to the queue header associated with the specified lock,
+ * or return NULL if there is no queue for the lock or if the lock's queue
+ * is in transition.
+ */
+static struct tkt_q_head *tkt_q_find_head(arch_spinlock_t *asp)

BTW, what does "asp" mean? arch_spinlock?

If so, can we just call it
"lock" and be consistent with all the other spinlock calls in the kernel. Because, I keep thinking this has something to do with Microsoft dynamic web pages.

-- Steve

Quoted 12 lines

kernel/tktqlock.c new file +12 -0

+{
+	int i;
+	int start;
+
+	start = i = tkt_q_hash(asp);
+	do
+		if (tkt_q_heads[i].ref == asp)
+			return &tkt_q_heads[i];
+	while ((i = tkt_q_next_slot(i)) != start);
+	return NULL;
+}
+

arch/x86/include/asm/spinlock.h +39 -0

+#else /* #ifndef CONFIG_TICKET_LOCK_QUEUED */
+
+bool tkt_spin_pass(arch_spinlock_t *ap, struct __raw_tickets inc);
+
+static __always_inline void __ticket_spin_lock(arch_spinlock_t *lock)
+{
+	register struct __raw_tickets inc = { .tail = 2 };
+
+	inc = xadd(&lock->tickets, inc);
+	for (;;) {
+		if (inc.head == inc.tail || tkt_spin_pass(lock, inc))
+			break;
+		inc.head = ACCESS_ONCE(lock->tickets.head);
+	}
+	barrier(); /* smp_mb() on Power or ARM. */
+}
+
+#endif /* #else #ifndef CONFIG_TICKET_LOCK_QUEUED */
+
 static __always_inline int __ticket_spin_trylock(arch_spinlock_t *lock)
 {
 	arch_spinlock_t old, new;

@@ -70,17 +91,37 @@ static __always_inline int __ticket_spin_trylock(arch_spinlock_t *lock)
 	if (old.tickets.head != old.tickets.tail)
 		return 0;
 
+#ifndef CONFIG_TICKET_LOCK_QUEUED
 	new.head_tail = old.head_tail + (1 << TICKET_SHIFT);
+#else /* #ifndef CONFIG_TICKET_LOCK_QUEUED */
+	new.head_tail = old.head_tail + (2 << TICKET_SHIFT);
+#endif /* #else #ifndef CONFIG_TICKET_LOCK_QUEUED */
 
 	/* cmpxchg is a full barrier, so nothing can move before it */
 	return cmpxchg(&lock->head_tail, old.head_tail, new.head_tail) == old.head_tail;
 }
 
+#ifndef CONFIG_TICKET_LOCK_QUEUED
+
 static __always_inline void __ticket_spin_unlock(arch_spinlock_t *lock)
 {
 	__add(&lock->tickets.head, 1, UNLOCK_LOCK_PREFIX);
 }
 
+#else /* #ifndef CONFIG_TICKET_LOCK_QUEUED */
+
+extern void tkt_q_do_wake(arch_spinlock_t *asp);
+
+static __always_inline void __ticket_spin_unlock(arch_spinlock_t *lock)
+{
+	__ticket_t head = 2;
+
+	head = xadd(&lock->tickets.head, 2);
+	if (head & 0x1)
+		tkt_q_do_wake(lock);
+}
+#endif /* #else #ifndef CONFIG_TICKET_LOCK_QUEUED */
+
 static inline int __ticket_spin_is_locked(arch_spinlock_t *lock)
 {
 	struct __raw_tickets tmp = ACCESS_ONCE(lock->tickets);

arch/x86/include/asm/spinlock_types.h +12 -2

index ad0ad07..cdaefdd 100644
@@ -7,12 +7,18 @@
 
 #include <linux/types.h>
 
-#if (CONFIG_NR_CPUS < 256)
+#if (CONFIG_NR_CPUS < 128)
 typedef u8  __ticket_t;
 typedef u16 __ticketpair_t;
-#else
+#define TICKET_T_CMP_GE(a, b) (UCHAR_MAX / 2 >= (unsigned char)((a) - (b)))
+#elif (CONFIG_NR_CPUS < 32768)
 typedef u16 __ticket_t;
 typedef u32 __ticketpair_t;
+#define TICKET_T_CMP_GE(a, b) (USHRT_MAX / 2 >= (unsigned short)((a) - (b)))
+#else
+typedef u32 __ticket_t;
+typedef u64 __ticketpair_t;
+#define TICKET_T_CMP_GE(a, b) (UINT_MAX / 2 >= (unsigned int)((a) - (b)))
 #endif
 
 #define TICKET_SHIFT	(sizeof(__ticket_t) * 8)

@@ -21,7 +27,11 @@ typedef struct arch_spinlock {
 	union {
 		__ticketpair_t head_tail;
 		struct __raw_tickets {
+#ifdef __BIG_ENDIAN__
+			__ticket_t tail, head;
+#else /* #ifdef __BIG_ENDIAN__ */
 			__ticket_t head, tail;
+#endif /* #else #ifdef __BIG_ENDIAN__ */
 		} tickets;
 	};
 } arch_spinlock_t;

include/linux/kernel.h +1 -0

index e9ef6d6..816a87c 100644
@@ -15,6 +15,7 @@
 #include <asm/byteorder.h>
 #include <uapi/linux/kernel.h>
 
+#define UCHAR_MAX	((u8)(~0U))
 #define USHRT_MAX	((u16)(~0U))
 #define SHRT_MAX	((s16)(USHRT_MAX>>1))
 #define SHRT_MIN	((s16)(-SHRT_MAX - 1))

kernel/Kconfig.locks +18 -0

index 44511d1..ad9c67c 100644
@@ -223,3 +223,21 @@ endif
 config MUTEX_SPIN_ON_OWNER
 	def_bool y
 	depends on SMP && !DEBUG_MUTEXES
+
+config TICKET_LOCK_QUEUED
+	bool "Dynamically switch between ticket and queued locking"
+	default n
+	---help---
+	  Enable dynamic switching between ticketlock and queued locking
+	  on a per-lock basis.  This option will slow down low-contention
+	  acquisition and release very slightly (additional conditional
+	  in release path), but will provide more efficient operation at
+	  high levels of lock contention.  High-contention operation will
+	  not be quite as efficient as would be a pure queued lock, but
+	  this dynamic approach consumes less memory than queud locks
+	  and also runs faster at low levels of contention.
+
+	  Say "Y" if you are running on a large system with a workload
+	  that is likely to result in high levels of contention.
+
+	  Say "N" if you are unsure.

kernel/Makefile +1 -0

index 271fd31..70a91f7 100644
@@ -51,6 +51,7 @@ endif
 obj-$(CONFIG_SMP) += spinlock.o
 obj-$(CONFIG_DEBUG_SPINLOCK) += spinlock.o
 obj-$(CONFIG_PROVE_LOCKING) += spinlock.o
+obj-$(CONFIG_TICKET_LOCK_QUEUED) += tktqlock.o
 obj-$(CONFIG_UID16) += uid16.o
 obj-$(CONFIG_MODULES) += module.o
 obj-$(CONFIG_MODULE_SIG) += module_signing.o modsign_pubkey.o modsign_certificate.o

kernel/tktqlock.c new file +175 -0

new file mode 100644
index 0000000..f01b760
@@ -0,0 +1,333 @@
+/*
+ * Queued ticket spinlocks.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * Copyright IBM Corporation, 2013
+ *
+ * Authors: Paul E. McKenney <[email protected]>
+ */
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/spinlock.h>
+#include <linux/smp.h>
+#include <linux/percpu.h>
+
+struct tkt_q {
+	int cpu;
+	__ticket_t tail;
+	struct tkt_q *next;
+};
+
+struct tkt_q_head {
+	arch_spinlock_t *ref;		/* Pointer to spinlock if in use. */
+	s32 head_tkt;			/* Head ticket when started queuing. */
+	struct tkt_q *spin;		/* Head of queue. */
+	struct tkt_q **spin_tail;	/* Tail of queue. */
+};
+
+/*
+ * TKT_Q_SWITCH is twice the number of CPUs that must be spinning on a
+ * given ticket lock to motivate switching to spinning on a queue.
+ * The reason that it is twice the number is because the bottom bit of
+ * the ticket is reserved for the bit that indicates that a queue is
+ * associated with the lock.
+ */
+#define TKT_Q_SWITCH  (16 * 2)
+
+/*
+ * TKT_Q_NQUEUES is the number of queues to maintain.  Large systems
+ * might have multiple highly contended locks, so provide more queues for
+ * systems with larger numbers of CPUs.
+ */
+#define TKT_Q_NQUEUES (DIV_ROUND_UP(NR_CPUS + TKT_Q_SWITCH - 1, TKT_Q_SWITCH) * 2)
+
+/* The queues themselves. */
+struct tkt_q_head tkt_q_heads[TKT_Q_NQUEUES];
+
+/* Advance to the next queue slot, wrapping around to the beginning. */
+static int tkt_q_next_slot(int i)
+{
+	return (++i < TKT_Q_NQUEUES) ? i : 0;
+}
+
+/* Very crude hash from lock address to queue slot number. */
+static unsigned long tkt_q_hash(arch_spinlock_t *asp)
+{
+	return (((unsigned long)asp) >> 8) % TKT_Q_NQUEUES;
+}
+
+/*
+ * Return a pointer to the queue header associated with the specified lock,
+ * or return NULL if there is no queue for the lock or if the lock's queue
+ * is in transition.
+ */
+static struct tkt_q_head *tkt_q_find_head(arch_spinlock_t *asp)
+{
+	int i;
+	int start;
+
+	start = i = tkt_q_hash(asp);
+	do
+		if (tkt_q_heads[i].ref == asp)
+			return &tkt_q_heads[i];
+	while ((i = tkt_q_next_slot(i)) != start);
+	return NULL;
+}
+
+/*
+ * Try to stop queuing, reverting back to normal ticket-lock operation.
+ * We can only stop queuing when the queue is empty, which means that
+ * we need to correctly handle races where someone shows up in the queue
+ * just as we are trying to dispense with the queue.  They win, we lose.
+ */
+static bool tkt_q_try_unqueue(arch_spinlock_t *asp, struct tkt_q_head *tqhp)
+{
+	arch_spinlock_t asold;
+	arch_spinlock_t asnew;
+
+	/* Pick up the ticket values. */
+	asold = ACCESS_ONCE(*asp);
+	if ((asold.tickets.head & ~0x1) == asold.tickets.tail) {
+
+		/* Attempt to mark the lock as not having a queue. */
+		asnew = asold;
+		asnew.tickets.head &= ~0x1;
+		if (cmpxchg(&asp->head_tail,
+			    asold.head_tail,
+			    asnew.head_tail) == asold.head_tail) {
+
+			/* Succeeded, mark the queue as unused. */
+			ACCESS_ONCE(tqhp->ref) = NULL;
+			return true;
+		}
+	}
+
+	/* Failed, tell the caller there is still a queue to pass off to. */
+	return false;
+}
+
+/*
+ * Hand the lock off to the first CPU on the queue.
+ */
+void tkt_q_do_wake(arch_spinlock_t *asp)
+{
+	struct tkt_q_head *tqhp;
+	struct tkt_q *tqp;
+
+	/* If the queue is still being set up, wait for it. */
+	while ((tqhp = tkt_q_find_head(asp)) == NULL)
+		cpu_relax();
+
+	for (;;) {
+
+		/* Find the first queue element. */
+		tqp = ACCESS_ONCE(tqhp->spin);
+		if (tqp != NULL)
+			break;  /* Element exists, hand off lock. */
+		if (tkt_q_try_unqueue(asp, tqhp))
+			return; /* No element, successfully removed queue. */
+		cpu_relax();
+	}
+	if (ACCESS_ONCE(tqhp->head_tkt) != -1)
+		ACCESS_ONCE(tqhp->head_tkt) = -1;
+	smp_mb(); /* Order pointer fetch and assignment against handoff. */
+	ACCESS_ONCE(tqp->cpu) = -1;
+}
+
+/*
+ * Given a lock that already has a queue associated with it, spin on
+ * that queue.  Return false if there was no queue (which means we do not
+ * hold the lock) and true otherwise (meaning we -do- hold the lock).
+ */
+bool tkt_q_do_spin(arch_spinlock_t *asp, struct __raw_tickets inc)
+{
+	struct tkt_q **oldtail;
+	struct tkt_q tq;
+	struct tkt_q_head *tqhp;
+
+	/*
+	 * Ensure that accesses to queue header happen after sensing
+	 * the lock's have-queue bit.
+	 */
+	smp_mb();  /* See above block comment. */
+
+	/* If there no longer is a queue, leave. */
+	tqhp = tkt_q_find_head(asp);
+	if (tqhp == NULL)
+		return false;
+
+	/* Initialize our queue element. */
+	tq.cpu = raw_smp_processor_id();
+	tq.tail = inc.tail;
+	tq.next = NULL;

kernel/tktqlock.c new file +128 -0

+			return true; /* Succeeded, queue is now empty. */
+
+		/* Failed, if needed, wait for the enqueue to complete. */
+		while (tq.next == NULL)
+			cpu_relax();
+
+		/* The following code will repair the head. */
+	}
+	smp_mb(); /* Force ordering between handoff and critical section. */
+
+	/* Advance list-head pointer. */
+	ACCESS_ONCE(tqhp->spin) = tq.next;
+	return true;
+}
+
+/*
+ * Given a lock that does not have a queue, attempt to associate the
+ * i-th queue with it, returning true if successful (meaning we hold
+ * the lock) or false otherwise (meaning we do -not- hold the lock).
+ * Note that the caller has already filled in ->ref with 0x1, so we
+ * own the queue.
+ */
+static bool
+tkt_q_init_contend(int i, arch_spinlock_t *asp, struct __raw_tickets inc)
+{
+	arch_spinlock_t asold;
+	arch_spinlock_t asnew;
+	struct tkt_q_head *tqhp;
+
+	/* Initialize the i-th queue header. */
+	tqhp = &tkt_q_heads[i];
+	tqhp->spin = NULL;
+	tqhp->spin_tail = &tqhp->spin;
+
+	/* Each pass through this loop attempts to mark the lock as queued. */
+	do {
+		asold.head_tail = ACCESS_ONCE(asp->head_tail);
+		asnew = asold;
+		if (asnew.tickets.head & 0x1) {
+
+			/* Someone beat us to it, back out. */
+			smp_mb();
+			ACCESS_ONCE(tqhp->ref) = NULL;
+
+			/* Spin on the queue element they set up. */
+			return tkt_q_do_spin(asp, inc);
+		}
+
+		/* The low-order bit in the head counter says "queued". */
+		asnew.tickets.head |= 0x1;
+	} while (cmpxchg(&asp->head_tail,
+		 asold.head_tail,
+		 asnew.head_tail) != asold.head_tail);
+
+	/* Point the queue at the lock and go spin on it. */
+	tqhp->head_tkt = asold.tickets.head;
+	smp_mb(); /* Ensure head_tkt is set prior to queuers seeing tqhp. */
+	ACCESS_ONCE(tqhp->ref) = asp;
+	return tkt_q_do_spin(asp, inc);
+}
+
+/*
+ * Start handling a period of high contention by finding a queue to associate
+ * with this lock.  Returns true if successful (in which case we hold the
+ * lock) and false otherwise (in which case we do -not- hold the lock).
+ */
+bool tkt_q_start_contend(arch_spinlock_t *asp, struct __raw_tickets inc)
+{
+	int i;
+	int start;
+
+	/* Hash the lock address to find a starting point. */
+	start = i = tkt_q_hash(asp);
+
+	/*
+	 * Each pass through the following loop attempts to associate
+	 * the lock with the corresponding queue.
+	 */
+	do {
+		/*
+		 * Use 0x1 to mark the queue in use, but also avoiding
+		 * any spinners trying to use it before we get it all
+		 * initialized.
+		 */
+		if (cmpxchg(&tkt_q_heads[i].ref,
+			    NULL,
+			    (arch_spinlock_t *)0x1) == NULL) {
+
+			/* Succeeded, now go initialize it. */
+			return tkt_q_init_contend(i, asp, inc);
+		}
+
+		/* If someone beat us to it, go spin on their queue. */
+		if (ACCESS_ONCE(asp->tickets.head) & 0x1)
+			return tkt_q_do_spin(asp, inc);
+	} while ((i = tkt_q_next_slot(i)) != start);
+
+	/* All the queues are in use, revert to spinning on the ticket lock. */
+	return false;
+}
+
+bool tkt_spin_pass(arch_spinlock_t *ap, struct __raw_tickets inc)
+{
+	if (unlikely(inc.head & 0x1)) {
+
+		/* This lock has a queue, so go spin on the queue. */
+		if (tkt_q_do_spin(ap, inc))
+			return true;
+
+		/* Get here if the queue is in transition: Retry next time. */
+
+	} else if (TICKET_T_CMP_GE(ACCESS_ONCE(ap->tickets.tail) - TKT_Q_SWITCH,
+				   ACCESS_ONCE(ap->tickets.head))) {
+
+		/*
+		 * This lock has lots of spinners, but no queue.
+		 * Go create a queue to spin on.
+		 */
+		if (tkt_q_start_contend(ap, inc))
+			return true;
+
+		/* Get here if the queue is in transition: Retry next time. */
+	}
+
+	/* Either no need for a queue or the queue is in transition.  Spin. */
+	cpu_relax();
+	return false;
+}

OK, I haven't found a issue here yet, but youss are beiing trickssy! We don't like trickssy, and we must find precccciouss!!!

Breaking up locks is better than implementing high-contention locks, but if we must have high-contention locks, why not make them automatically switch between light-weight ticket locks at low contention and queued locks at high contention?

This commit therefore allows ticket locks to automatically switch between pure ticketlock and queued-lock operation as needed. If too many CPUs are spinning on a given ticket lock, a queue structure will be allocated and the lock will switch to queued-lock operation. When the lock becomes free, it will switch back into ticketlock operation. The low-order bit of the head counter is used to indicate that the lock is in queued mode, which forces an unconditional mismatch between the head and tail counters. This approach means that the common-case code path under conditions of low contention is very nearly that of a plain ticket lock.

A fixed number of queueing structures is statically allocated in an array. The ticket-lock address is used to hash into an initial element, but if that element is already in use, it moves to the next element. If the entire array is already in use, continue to spin in ticket mode.

This has been only lightly tested in the kernel, though a userspace implementation has survived substantial testing.

Signed-off-by Paul E. McKenney <[email protected]>

arch/x86/include/asm/spinlock.h +41 -0

index 33692ea..b4a91b0 100644
@@ -34,6 +34,8 @@
 # define UNLOCK_LOCK_PREFIX
 #endif
 
+#ifndef CONFIG_TICKET_LOCK_QUEUED
+
 /*
  * Ticket locks are conceptually two parts, one indicating the current head of
  * the queue, and the other indicating the current tail. The lock is acquired

@@ -62,6 +64,25 @@ static __always_inline void __ticket_spin_lock(arch_spinlock_t *lock)
 	barrier();		/* make sure nothing creeps before the lock is taken */
 }
 
+#else /* #ifndef CONFIG_TICKET_LOCK_QUEUED */
+
+bool tkt_spin_pass(arch_spinlock_t *ap, struct __raw_tickets inc);
+
+static __always_inline void __ticket_spin_lock(arch_spinlock_t *lock)
+{
+	register struct __raw_tickets inc = { .tail = 2 };
+
+	inc = xadd(&lock->tickets, inc);
+	for (;;) {
+		if (inc.head == inc.tail || tkt_spin_pass(lock, inc))
+			break;
+		inc.head = ACCESS_ONCE(lock->tickets.head);
+	}
+	barrier(); /* smp_mb() on Power or ARM. */
+}
+
+#endif /* #else #ifndef CONFIG_TICKET_LOCK_QUEUED */
+
 static __always_inline int __ticket_spin_trylock(arch_spinlock_t *lock)
 {
 	arch_spinlock_t old, new;

@@ -70,17 +91,37 @@ static __always_inline int __ticket_spin_trylock(arch_spinlock_t *lock)
 	if (old.tickets.head != old.tickets.tail)
 		return 0;
 
+#ifndef CONFIG_TICKET_LOCK_QUEUED
 	new.head_tail = old.head_tail + (1 << TICKET_SHIFT);
+#else /* #ifndef CONFIG_TICKET_LOCK_QUEUED */
+	new.head_tail = old.head_tail + (2 << TICKET_SHIFT);
+#endif /* #else #ifndef CONFIG_TICKET_LOCK_QUEUED */
 
 	/* cmpxchg is a full barrier, so nothing can move before it */
 	return cmpxchg(&lock->head_tail, old.head_tail, new.head_tail) == old.head_tail;
 }
 
+#ifndef CONFIG_TICKET_LOCK_QUEUED
+
 static __always_inline void __ticket_spin_unlock(arch_spinlock_t *lock)
 {
 	__add(&lock->tickets.head, 1, UNLOCK_LOCK_PREFIX);
 }
 
+#else /* #ifndef CONFIG_TICKET_LOCK_QUEUED */
+
+extern void tkt_q_do_wake(arch_spinlock_t *asp);
+
+static __always_inline void __ticket_spin_unlock(arch_spinlock_t *lock)
+{
+	__ticket_t head = 2;
+
+	head = xadd(&lock->tickets.head, 2);
+	if (head & 0x1)
+		tkt_q_do_wake(lock);
+}
+#endif /* #else #ifndef CONFIG_TICKET_LOCK_QUEUED */
+
 static inline int __ticket_spin_is_locked(arch_spinlock_t *lock)
 {
 	struct __raw_tickets tmp = ACCESS_ONCE(lock->tickets);

arch/x86/include/asm/spinlock_types.h +12 -2

index ad0ad07..cdaefdd 100644
@@ -7,12 +7,18 @@
 
 #include <linux/types.h>
 
-#if (CONFIG_NR_CPUS < 256)
+#if (CONFIG_NR_CPUS < 128)
 typedef u8  __ticket_t;
 typedef u16 __ticketpair_t;
-#else
+#define TICKET_T_CMP_GE(a, b) (UCHAR_MAX / 2 >= (unsigned char)((a) - (b)))
+#elif (CONFIG_NR_CPUS < 32768)
 typedef u16 __ticket_t;
 typedef u32 __ticketpair_t;
+#define TICKET_T_CMP_GE(a, b) (USHRT_MAX / 2 >= (unsigned short)((a) - (b)))
+#else
+typedef u32 __ticket_t;
+typedef u64 __ticketpair_t;
+#define TICKET_T_CMP_GE(a, b) (UINT_MAX / 2 >= (unsigned int)((a) - (b)))
 #endif
 
 #define TICKET_SHIFT	(sizeof(__ticket_t) * 8)

@@ -21,7 +27,11 @@ typedef struct arch_spinlock {
 	union {
 		__ticketpair_t head_tail;
 		struct __raw_tickets {
+#ifdef __BIG_ENDIAN__
+			__ticket_t tail, head;
+#else /* #ifdef __BIG_ENDIAN__ */
 			__ticket_t head, tail;
+#endif /* #else #ifdef __BIG_ENDIAN__ */
 		} tickets;
 	};
 } arch_spinlock_t;

include/linux/kernel.h +1 -0

index e9ef6d6..816a87c 100644
@@ -15,6 +15,7 @@
 #include <asm/byteorder.h>
 #include <uapi/linux/kernel.h>
 
+#define UCHAR_MAX	((u8)(~0U))
 #define USHRT_MAX	((u16)(~0U))
 #define SHRT_MAX	((s16)(USHRT_MAX>>1))
 #define SHRT_MIN	((s16)(-SHRT_MAX - 1))

kernel/Kconfig.locks +18 -0

index 44511d1..ad9c67c 100644
@@ -223,3 +223,21 @@ endif
 config MUTEX_SPIN_ON_OWNER
 	def_bool y
 	depends on SMP && !DEBUG_MUTEXES
+
+config TICKET_LOCK_QUEUED
+	bool "Dynamically switch between ticket and queued locking"
+	default n
+	---help---
+	  Enable dynamic switching between ticketlock and queued locking
+	  on a per-lock basis.  This option will slow down low-contention
+	  acquisition and release very slightly (additional conditional
+	  in release path), but will provide more efficient operation at
+	  high levels of lock contention.  High-contention operation will
+	  not be quite as efficient as would be a pure queued lock, but
+	  this dynamic approach consumes less memory than queud locks
+	  and also runs faster at low levels of contention.
+
+	  Say "Y" if you are running on a large system with a workload
+	  that is likely to result in high levels of contention.
+
+	  Say "N" if you are unsure.

kernel/Makefile +1 -0

index 271fd31..70a91f7 100644
@@ -51,6 +51,7 @@ endif
 obj-$(CONFIG_SMP) += spinlock.o
 obj-$(CONFIG_DEBUG_SPINLOCK) += spinlock.o
 obj-$(CONFIG_PROVE_LOCKING) += spinlock.o
+obj-$(CONFIG_TICKET_LOCK_QUEUED) += tktqlock.o
 obj-$(CONFIG_UID16) += uid16.o
 obj-$(CONFIG_MODULES) += module.o
 obj-$(CONFIG_MODULE_SIG) += module_signing.o modsign_pubkey.o modsign_certificate.o

kernel/tktqlock.c new file +333 -0

new file mode 100644
index 0000000..f01b760
@@ -0,0 +1,333 @@
+/*
+ * Queued ticket spinlocks.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * Copyright IBM Corporation, 2013
+ *
+ * Authors: Paul E. McKenney <[email protected]>
+ */
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/spinlock.h>
+#include <linux/smp.h>
+#include <linux/percpu.h>
+
+struct tkt_q {
+	int cpu;
+	__ticket_t tail;
+	struct tkt_q *next;
+};
+
+struct tkt_q_head {
+	arch_spinlock_t *ref;		/* Pointer to spinlock if in use. */
+	s32 head_tkt;			/* Head ticket when started queuing. */
+	struct tkt_q *spin;		/* Head of queue. */
+	struct tkt_q **spin_tail;	/* Tail of queue. */
+};
+
+/*
+ * TKT_Q_SWITCH is twice the number of CPUs that must be spinning on a
+ * given ticket lock to motivate switching to spinning on a queue.
+ * The reason that it is twice the number is because the bottom bit of
+ * the ticket is reserved for the bit that indicates that a queue is
+ * associated with the lock.
+ */
+#define TKT_Q_SWITCH  (16 * 2)
+
+/*
+ * TKT_Q_NQUEUES is the number of queues to maintain.  Large systems
+ * might have multiple highly contended locks, so provide more queues for
+ * systems with larger numbers of CPUs.
+ */
+#define TKT_Q_NQUEUES (DIV_ROUND_UP(NR_CPUS + TKT_Q_SWITCH - 1, TKT_Q_SWITCH) * 2)
+
+/* The queues themselves. */
+struct tkt_q_head tkt_q_heads[TKT_Q_NQUEUES];
+
+/* Advance to the next queue slot, wrapping around to the beginning. */
+static int tkt_q_next_slot(int i)
+{
+	return (++i < TKT_Q_NQUEUES) ? i : 0;
+}
+
+/* Very crude hash from lock address to queue slot number. */
+static unsigned long tkt_q_hash(arch_spinlock_t *asp)
+{
+	return (((unsigned long)asp) >> 8) % TKT_Q_NQUEUES;
+}
+
+/*
+ * Return a pointer to the queue header associated with the specified lock,
+ * or return NULL if there is no queue for the lock or if the lock's queue
+ * is in transition.
+ */
+static struct tkt_q_head *tkt_q_find_head(arch_spinlock_t *asp)
+{
+	int i;
+	int start;
+
+	start = i = tkt_q_hash(asp);
+	do
+		if (tkt_q_heads[i].ref == asp)
+			return &tkt_q_heads[i];
+	while ((i = tkt_q_next_slot(i)) != start);
+	return NULL;
+}
+
+/*
+ * Try to stop queuing, reverting back to normal ticket-lock operation.
+ * We can only stop queuing when the queue is empty, which means that
+ * we need to correctly handle races where someone shows up in the queue
+ * just as we are trying to dispense with the queue.  They win, we lose.
+ */
+static bool tkt_q_try_unqueue(arch_spinlock_t *asp, struct tkt_q_head *tqhp)
+{
+	arch_spinlock_t asold;
+	arch_spinlock_t asnew;
+
+	/* Pick up the ticket values. */
+	asold = ACCESS_ONCE(*asp);
+	if ((asold.tickets.head & ~0x1) == asold.tickets.tail) {
+
+		/* Attempt to mark the lock as not having a queue. */
+		asnew = asold;
+		asnew.tickets.head &= ~0x1;
+		if (cmpxchg(&asp->head_tail,
+			    asold.head_tail,
+			    asnew.head_tail) == asold.head_tail) {
+
+			/* Succeeded, mark the queue as unused. */
+			ACCESS_ONCE(tqhp->ref) = NULL;
+			return true;
+		}
+	}
+
+	/* Failed, tell the caller there is still a queue to pass off to. */
+	return false;
+}
+
+/*
+ * Hand the lock off to the first CPU on the queue.
+ */
+void tkt_q_do_wake(arch_spinlock_t *asp)
+{
+	struct tkt_q_head *tqhp;
+	struct tkt_q *tqp;
+
+	/* If the queue is still being set up, wait for it. */
+	while ((tqhp = tkt_q_find_head(asp)) == NULL)
+		cpu_relax();
+
+	for (;;) {
+
+		/* Find the first queue element. */
+		tqp = ACCESS_ONCE(tqhp->spin);
+		if (tqp != NULL)
+			break;  /* Element exists, hand off lock. */
+		if (tkt_q_try_unqueue(asp, tqhp))
+			return; /* No element, successfully removed queue. */
+		cpu_relax();
+	}
+	if (ACCESS_ONCE(tqhp->head_tkt) != -1)
+		ACCESS_ONCE(tqhp->head_tkt) = -1;
+	smp_mb(); /* Order pointer fetch and assignment against handoff. */
+	ACCESS_ONCE(tqp->cpu) = -1;
+}
+
+/*
+ * Given a lock that already has a queue associated with it, spin on
+ * that queue.  Return false if there was no queue (which means we do not
+ * hold the lock) and true otherwise (meaning we -do- hold the lock).
+ */
+bool tkt_q_do_spin(arch_spinlock_t *asp, struct __raw_tickets inc)
+{
+	struct tkt_q **oldtail;
+	struct tkt_q tq;
+	struct tkt_q_head *tqhp;
+
+	/*
+	 * Ensure that accesses to queue header happen after sensing
+	 * the lock's have-queue bit.
+	 */
+	smp_mb();  /* See above block comment. */
+
+	/* If there no longer is a queue, leave. */
+	tqhp = tkt_q_find_head(asp);
+	if (tqhp == NULL)
+		return false;
+
+	/* Initialize our queue element. */
+	tq.cpu = raw_smp_processor_id();
+	tq.tail = inc.tail;
+	tq.next = NULL;
+
+	/* Check to see if we already hold the lock. */
+	if (ACCESS_ONCE(tqhp->head_tkt) == inc.tail) {
+		/* The last holder left before queue formed, we hold lock. */
+		tqhp->head_tkt = -1;
+		return true;
+	}
+
+	/* Add our element to the tail of the queue. */
+	oldtail = xchg(&tqhp->spin_tail, &tq.next);
+	ACCESS_ONCE(*oldtail) = &tq;
+
+	/* Spin until handoff. */
+	while (ACCESS_ONCE(tq.cpu) != -1)
+		cpu_relax();
+
+	/*
+	 * Remove our element from the queue.  If the queue is now empty,
+	 * update carefully so that the next acquisition will queue itself
+	 * at the head of the list.
+	 */
+	if (tq.next == NULL) {
+
+		/* Mark the queue empty. */
+		tqhp->spin = NULL;
+
+		/* Try to point the tail back at the head. */
+		if (cmpxchg(&tqhp->spin_tail,
+			    &tq.next,
+			    &tqhp->spin) == &tq.next)
+			return true; /* Succeeded, queue is now empty. */
+
+		/* Failed, if needed, wait for the enqueue to complete. */
+		while (tq.next == NULL)
+			cpu_relax();
+
+		/* The following code will repair the head. */
+	}
+	smp_mb(); /* Force ordering between handoff and critical section. */
+
+	/* Advance list-head pointer. */
+	ACCESS_ONCE(tqhp->spin) = tq.next;
+	return true;
+}
+
+/*
+ * Given a lock that does not have a queue, attempt to associate the
+ * i-th queue with it, returning true if successful (meaning we hold
+ * the lock) or false otherwise (meaning we do -not- hold the lock).
+ * Note that the caller has already filled in ->ref with 0x1, so we
+ * own the queue.
+ */
+static bool
+tkt_q_init_contend(int i, arch_spinlock_t *asp, struct __raw_tickets inc)
+{
+	arch_spinlock_t asold;
+	arch_spinlock_t asnew;
+	struct tkt_q_head *tqhp;
+
+	/* Initialize the i-th queue header. */
+	tqhp = &tkt_q_heads[i];
+	tqhp->spin = NULL;
+	tqhp->spin_tail = &tqhp->spin;
+
+	/* Each pass through this loop attempts to mark the lock as queued. */
+	do {
+		asold.head_tail = ACCESS_ONCE(asp->head_tail);
+		asnew = asold;
+		if (asnew.tickets.head & 0x1) {
+
+			/* Someone beat us to it, back out. */
+			smp_mb();
+			ACCESS_ONCE(tqhp->ref) = NULL;
+
+			/* Spin on the queue element they set up. */
+			return tkt_q_do_spin(asp, inc);
+		}
+
+		/* The low-order bit in the head counter says "queued". */
+		asnew.tickets.head |= 0x1;
+	} while (cmpxchg(&asp->head_tail,
+		 asold.head_tail,
+		 asnew.head_tail) != asold.head_tail);
+
+	/* Point the queue at the lock and go spin on it. */
+	tqhp->head_tkt = asold.tickets.head;
+	smp_mb(); /* Ensure head_tkt is set prior to queuers seeing tqhp. */
+	ACCESS_ONCE(tqhp->ref) = asp;
+	return tkt_q_do_spin(asp, inc);
+}
+
+/*
+ * Start handling a period of high contention by finding a queue to associate
+ * with this lock.  Returns true if successful (in which case we hold the
+ * lock) and false otherwise (in which case we do -not- hold the lock).
+ */
+bool tkt_q_start_contend(arch_spinlock_t *asp, struct __raw_tickets inc)
+{
+	int i;
+	int start;
+
+	/* Hash the lock address to find a starting point. */
+	start = i = tkt_q_hash(asp);
+
+	/*
+	 * Each pass through the following loop attempts to associate
+	 * the lock with the corresponding queue.
+	 */
+	do {
+		/*
+		 * Use 0x1 to mark the queue in use, but also avoiding
+		 * any spinners trying to use it before we get it all
+		 * initialized.
+		 */
+		if (cmpxchg(&tkt_q_heads[i].ref,
+			    NULL,
+			    (arch_spinlock_t *)0x1) == NULL) {
+
+			/* Succeeded, now go initialize it. */
+			return tkt_q_init_contend(i, asp, inc);
+		}
+
+		/* If someone beat us to it, go spin on their queue. */
+		if (ACCESS_ONCE(asp->tickets.head) & 0x1)
+			return tkt_q_do_spin(asp, inc);
+	} while ((i = tkt_q_next_slot(i)) != start);
+
+	/* All the queues are in use, revert to spinning on the ticket lock. */
+	return false;
+}
+
+bool tkt_spin_pass(arch_spinlock_t *ap, struct __raw_tickets inc)
+{
+	if (unlikely(inc.head & 0x1)) {
+
+		/* This lock has a queue, so go spin on the queue. */
+		if (tkt_q_do_spin(ap, inc))
+			return true;
+
+		/* Get here if the queue is in transition: Retry next time. */
+
+	} else if (TICKET_T_CMP_GE(ACCESS_ONCE(ap->tickets.tail) - TKT_Q_SWITCH,
+				   ACCESS_ONCE(ap->tickets.head))) {
+
+		/*
+		 * This lock has lots of spinners, but no queue.
+		 * Go create a queue to spin on.
+		 */
+		if (tkt_q_start_contend(ap, inc))
+			return true;
+
+		/* Get here if the queue is in transition: Retry next time. */
+	}
+
+	/* Either no need for a queue or the queue is in transition.  Spin. */
+	cpu_relax();
+	return false;
+}

Quoted 3 lines · Steven Rostedt

OK, I haven't found a issue here yet, but youss are beiing trickssy! We don't like trickssy, and we must find precccciouss!!!

.. and I personally have my usual reservations. I absolutely hate papering over scalability issues, and historically whenever people have ever thought that we want complex spinlocks, the problem has always been that the locking sucks.

So reinforced by previous events, I really feel that code that needs this kind of spinlock is broken and needs to be fixed, rather than actually introduce tricky spinlocks.

So in order to merge something like this, I want (a) numbers for real loads and (b) explanations for why the spinlock users cannot be fixed.

Because "we might hit loads" is just not good enough. I would counter with "hiding problems causes more of them".

Quoted 20 lines · Paul E. McKenney

Breaking up locks is better than implementing high-contention locks, but if we must have high-contention locks, why not make them automatically switch between light-weight ticket locks at low contention and queued locks at high contention?

This commit therefore allows ticket locks to automatically switch between pure ticketlock and queued-lock operation as needed. If too many CPUs are spinning on a given ticket lock, a queue structure will be allocated and the lock will switch to queued-lock operation. When the lock becomes free, it will switch back into ticketlock operation. The low-order bit of the head counter is used to indicate that the lock is in queued mode, which forces an unconditional mismatch between the head and tail counters. This approach means that the common-case code path under conditions of low contention is very nearly that of a plain ticket lock.

A fixed number of queueing structures is statically allocated in an array. The ticket-lock address is used to hash into an initial element, but if that element is already in use, it moves to the next element. If the entire array is already in use, continue to spin in ticket mode.

Quoted 2 lines

This has been only lightly tested in the kernel, though a userspace implementation has survived substantial testing.

I guess the point of this patch is to lower the cache ping pong effect of spin locks. I believe Rik was doing something similar to this as well.

Now, when we switch from ticket to queue, we basically blow away the old FIFO and all the tasks do a thundering herd to get on the queue. Even if the task was next to get the lock, it could end up being stuck at the back of the queue again and have to wait. When I put my real-time hat on, this bothers me. Even though it's still a bound latency, as it only gets put to the end of the queue once, it just doubled the length of the worse case grabbing of a lock.

-- Steve

Quoted 506 lines

Signed-off-by Paul E. McKenney <[email protected]>

arch/x86/include/asm/spinlock.h +41 -0

index 33692ea..b4a91b0 100644
@@ -34,6 +34,8 @@
 # define UNLOCK_LOCK_PREFIX
 #endif
 
+#ifndef CONFIG_TICKET_LOCK_QUEUED
+
 /*
  * Ticket locks are conceptually two parts, one indicating the current head of
  * the queue, and the other indicating the current tail. The lock is acquired

@@ -62,6 +64,25 @@ static __always_inline void __ticket_spin_lock(arch_spinlock_t *lock)
 	barrier();		/* make sure nothing creeps before the lock is taken */
 }
 
+#else /* #ifndef CONFIG_TICKET_LOCK_QUEUED */
+
+bool tkt_spin_pass(arch_spinlock_t *ap, struct __raw_tickets inc);
+
+static __always_inline void __ticket_spin_lock(arch_spinlock_t *lock)
+{
+	register struct __raw_tickets inc = { .tail = 2 };
+
+	inc = xadd(&lock->tickets, inc);
+	for (;;) {
+		if (inc.head == inc.tail || tkt_spin_pass(lock, inc))
+			break;
+		inc.head = ACCESS_ONCE(lock->tickets.head);
+	}
+	barrier(); /* smp_mb() on Power or ARM. */
+}
+
+#endif /* #else #ifndef CONFIG_TICKET_LOCK_QUEUED */
+
 static __always_inline int __ticket_spin_trylock(arch_spinlock_t *lock)
 {
 	arch_spinlock_t old, new;

@@ -70,17 +91,37 @@ static __always_inline int __ticket_spin_trylock(arch_spinlock_t *lock)
 	if (old.tickets.head != old.tickets.tail)
 		return 0;
 
+#ifndef CONFIG_TICKET_LOCK_QUEUED
 	new.head_tail = old.head_tail + (1 << TICKET_SHIFT);
+#else /* #ifndef CONFIG_TICKET_LOCK_QUEUED */
+	new.head_tail = old.head_tail + (2 << TICKET_SHIFT);
+#endif /* #else #ifndef CONFIG_TICKET_LOCK_QUEUED */
 
 	/* cmpxchg is a full barrier, so nothing can move before it */
 	return cmpxchg(&lock->head_tail, old.head_tail, new.head_tail) == old.head_tail;
 }
 
+#ifndef CONFIG_TICKET_LOCK_QUEUED
+
 static __always_inline void __ticket_spin_unlock(arch_spinlock_t *lock)
 {
 	__add(&lock->tickets.head, 1, UNLOCK_LOCK_PREFIX);
 }
 
+#else /* #ifndef CONFIG_TICKET_LOCK_QUEUED */
+
+extern void tkt_q_do_wake(arch_spinlock_t *asp);
+
+static __always_inline void __ticket_spin_unlock(arch_spinlock_t *lock)
+{
+	__ticket_t head = 2;
+
+	head = xadd(&lock->tickets.head, 2);
+	if (head & 0x1)
+		tkt_q_do_wake(lock);
+}
+#endif /* #else #ifndef CONFIG_TICKET_LOCK_QUEUED */
+
 static inline int __ticket_spin_is_locked(arch_spinlock_t *lock)
 {
 	struct __raw_tickets tmp = ACCESS_ONCE(lock->tickets);

arch/x86/include/asm/spinlock_types.h +12 -2

index ad0ad07..cdaefdd 100644
@@ -7,12 +7,18 @@
 
 #include <linux/types.h>
 
-#if (CONFIG_NR_CPUS < 256)
+#if (CONFIG_NR_CPUS < 128)
 typedef u8  __ticket_t;
 typedef u16 __ticketpair_t;
-#else
+#define TICKET_T_CMP_GE(a, b) (UCHAR_MAX / 2 >= (unsigned char)((a) - (b)))
+#elif (CONFIG_NR_CPUS < 32768)
 typedef u16 __ticket_t;
 typedef u32 __ticketpair_t;
+#define TICKET_T_CMP_GE(a, b) (USHRT_MAX / 2 >= (unsigned short)((a) - (b)))
+#else
+typedef u32 __ticket_t;
+typedef u64 __ticketpair_t;
+#define TICKET_T_CMP_GE(a, b) (UINT_MAX / 2 >= (unsigned int)((a) - (b)))
 #endif
 
 #define TICKET_SHIFT	(sizeof(__ticket_t) * 8)

@@ -21,7 +27,11 @@ typedef struct arch_spinlock {
 	union {
 		__ticketpair_t head_tail;
 		struct __raw_tickets {
+#ifdef __BIG_ENDIAN__
+			__ticket_t tail, head;
+#else /* #ifdef __BIG_ENDIAN__ */
 			__ticket_t head, tail;
+#endif /* #else #ifdef __BIG_ENDIAN__ */
 		} tickets;
 	};
 } arch_spinlock_t;

include/linux/kernel.h +1 -0

index e9ef6d6..816a87c 100644
@@ -15,6 +15,7 @@
 #include <asm/byteorder.h>
 #include <uapi/linux/kernel.h>
 
+#define UCHAR_MAX	((u8)(~0U))
 #define USHRT_MAX	((u16)(~0U))
 #define SHRT_MAX	((s16)(USHRT_MAX>>1))
 #define SHRT_MIN	((s16)(-SHRT_MAX - 1))

kernel/Kconfig.locks +18 -0

index 44511d1..ad9c67c 100644
@@ -223,3 +223,21 @@ endif
 config MUTEX_SPIN_ON_OWNER
 	def_bool y
 	depends on SMP && !DEBUG_MUTEXES
+
+config TICKET_LOCK_QUEUED
+	bool "Dynamically switch between ticket and queued locking"
+	default n
+	---help---
+	  Enable dynamic switching between ticketlock and queued locking
+	  on a per-lock basis.  This option will slow down low-contention
+	  acquisition and release very slightly (additional conditional
+	  in release path), but will provide more efficient operation at
+	  high levels of lock contention.  High-contention operation will
+	  not be quite as efficient as would be a pure queued lock, but
+	  this dynamic approach consumes less memory than queud locks
+	  and also runs faster at low levels of contention.
+
+	  Say "Y" if you are running on a large system with a workload
+	  that is likely to result in high levels of contention.
+
+	  Say "N" if you are unsure.

kernel/Makefile +1 -0

index 271fd31..70a91f7 100644
@@ -51,6 +51,7 @@ endif
 obj-$(CONFIG_SMP) += spinlock.o
 obj-$(CONFIG_DEBUG_SPINLOCK) += spinlock.o
 obj-$(CONFIG_PROVE_LOCKING) += spinlock.o
+obj-$(CONFIG_TICKET_LOCK_QUEUED) += tktqlock.o
 obj-$(CONFIG_UID16) += uid16.o
 obj-$(CONFIG_MODULES) += module.o
 obj-$(CONFIG_MODULE_SIG) += module_signing.o modsign_pubkey.o modsign_certificate.o

kernel/tktqlock.c new file +333 -0

new file mode 100644
index 0000000..f01b760
@@ -0,0 +1,333 @@
+/*
+ * Queued ticket spinlocks.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * Copyright IBM Corporation, 2013
+ *
+ * Authors: Paul E. McKenney <[email protected]>
+ */
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/spinlock.h>
+#include <linux/smp.h>
+#include <linux/percpu.h>
+
+struct tkt_q {
+	int cpu;
+	__ticket_t tail;
+	struct tkt_q *next;
+};
+
+struct tkt_q_head {
+	arch_spinlock_t *ref;		/* Pointer to spinlock if in use. */
+	s32 head_tkt;			/* Head ticket when started queuing. */
+	struct tkt_q *spin;		/* Head of queue. */
+	struct tkt_q **spin_tail;	/* Tail of queue. */
+};
+
+/*
+ * TKT_Q_SWITCH is twice the number of CPUs that must be spinning on a
+ * given ticket lock to motivate switching to spinning on a queue.
+ * The reason that it is twice the number is because the bottom bit of
+ * the ticket is reserved for the bit that indicates that a queue is
+ * associated with the lock.
+ */
+#define TKT_Q_SWITCH  (16 * 2)
+
+/*
+ * TKT_Q_NQUEUES is the number of queues to maintain.  Large systems
+ * might have multiple highly contended locks, so provide more queues for
+ * systems with larger numbers of CPUs.
+ */
+#define TKT_Q_NQUEUES (DIV_ROUND_UP(NR_CPUS + TKT_Q_SWITCH - 1, TKT_Q_SWITCH) * 2)
+
+/* The queues themselves. */
+struct tkt_q_head tkt_q_heads[TKT_Q_NQUEUES];
+
+/* Advance to the next queue slot, wrapping around to the beginning. */
+static int tkt_q_next_slot(int i)
+{
+	return (++i < TKT_Q_NQUEUES) ? i : 0;
+}
+
+/* Very crude hash from lock address to queue slot number. */
+static unsigned long tkt_q_hash(arch_spinlock_t *asp)
+{
+	return (((unsigned long)asp) >> 8) % TKT_Q_NQUEUES;
+}
+
+/*
+ * Return a pointer to the queue header associated with the specified lock,
+ * or return NULL if there is no queue for the lock or if the lock's queue
+ * is in transition.
+ */
+static struct tkt_q_head *tkt_q_find_head(arch_spinlock_t *asp)
+{
+	int i;
+	int start;
+
+	start = i = tkt_q_hash(asp);
+	do
+		if (tkt_q_heads[i].ref == asp)
+			return &tkt_q_heads[i];
+	while ((i = tkt_q_next_slot(i)) != start);
+	return NULL;
+}
+
+/*
+ * Try to stop queuing, reverting back to normal ticket-lock operation.
+ * We can only stop queuing when the queue is empty, which means that
+ * we need to correctly handle races where someone shows up in the queue
+ * just as we are trying to dispense with the queue.  They win, we lose.
+ */
+static bool tkt_q_try_unqueue(arch_spinlock_t *asp, struct tkt_q_head *tqhp)
+{
+	arch_spinlock_t asold;
+	arch_spinlock_t asnew;
+
+	/* Pick up the ticket values. */
+	asold = ACCESS_ONCE(*asp);
+	if ((asold.tickets.head & ~0x1) == asold.tickets.tail) {
+
+		/* Attempt to mark the lock as not having a queue. */
+		asnew = asold;
+		asnew.tickets.head &= ~0x1;
+		if (cmpxchg(&asp->head_tail,
+			    asold.head_tail,
+			    asnew.head_tail) == asold.head_tail) {
+
+			/* Succeeded, mark the queue as unused. */
+			ACCESS_ONCE(tqhp->ref) = NULL;
+			return true;
+		}
+	}
+
+	/* Failed, tell the caller there is still a queue to pass off to. */
+	return false;
+}
+
+/*
+ * Hand the lock off to the first CPU on the queue.
+ */
+void tkt_q_do_wake(arch_spinlock_t *asp)
+{
+	struct tkt_q_head *tqhp;
+	struct tkt_q *tqp;
+
+	/* If the queue is still being set up, wait for it. */
+	while ((tqhp = tkt_q_find_head(asp)) == NULL)
+		cpu_relax();
+
+	for (;;) {
+
+		/* Find the first queue element. */
+		tqp = ACCESS_ONCE(tqhp->spin);
+		if (tqp != NULL)
+			break;  /* Element exists, hand off lock. */
+		if (tkt_q_try_unqueue(asp, tqhp))
+			return; /* No element, successfully removed queue. */
+		cpu_relax();
+	}
+	if (ACCESS_ONCE(tqhp->head_tkt) != -1)
+		ACCESS_ONCE(tqhp->head_tkt) = -1;
+	smp_mb(); /* Order pointer fetch and assignment against handoff. */
+	ACCESS_ONCE(tqp->cpu) = -1;
+}
+
+/*
+ * Given a lock that already has a queue associated with it, spin on
+ * that queue.  Return false if there was no queue (which means we do not
+ * hold the lock) and true otherwise (meaning we -do- hold the lock).
+ */
+bool tkt_q_do_spin(arch_spinlock_t *asp, struct __raw_tickets inc)
+{
+	struct tkt_q **oldtail;
+	struct tkt_q tq;
+	struct tkt_q_head *tqhp;
+
+	/*
+	 * Ensure that accesses to queue header happen after sensing
+	 * the lock's have-queue bit.
+	 */
+	smp_mb();  /* See above block comment. */
+
+	/* If there no longer is a queue, leave. */
+	tqhp = tkt_q_find_head(asp);
+	if (tqhp == NULL)
+		return false;
+
+	/* Initialize our queue element. */
+	tq.cpu = raw_smp_processor_id();
+	tq.tail = inc.tail;
+	tq.next = NULL;
+
+	/* Check to see if we already hold the lock. */
+	if (ACCESS_ONCE(tqhp->head_tkt) == inc.tail) {
+		/* The last holder left before queue formed, we hold lock. */
+		tqhp->head_tkt = -1;
+		return true;
+	}
+
+	/* Add our element to the tail of the queue. */
+	oldtail = xchg(&tqhp->spin_tail, &tq.next);
+	ACCESS_ONCE(*oldtail) = &tq;
+
+	/* Spin until handoff. */
+	while (ACCESS_ONCE(tq.cpu) != -1)
+		cpu_relax();
+
+	/*
+	 * Remove our element from the queue.  If the queue is now empty,
+	 * update carefully so that the next acquisition will queue itself
+	 * at the head of the list.
+	 */
+	if (tq.next == NULL) {
+
+		/* Mark the queue empty. */
+		tqhp->spin = NULL;
+
+		/* Try to point the tail back at the head. */
+		if (cmpxchg(&tqhp->spin_tail,
+			    &tq.next,
+			    &tqhp->spin) == &tq.next)
+			return true; /* Succeeded, queue is now empty. */
+
+		/* Failed, if needed, wait for the enqueue to complete. */
+		while (tq.next == NULL)
+			cpu_relax();
+
+		/* The following code will repair the head. */
+	}
+	smp_mb(); /* Force ordering between handoff and critical section. */
+
+	/* Advance list-head pointer. */
+	ACCESS_ONCE(tqhp->spin) = tq.next;
+	return true;
+}
+
+/*
+ * Given a lock that does not have a queue, attempt to associate the
+ * i-th queue with it, returning true if successful (meaning we hold
+ * the lock) or false otherwise (meaning we do -not- hold the lock).
+ * Note that the caller has already filled in ->ref with 0x1, so we
+ * own the queue.
+ */
+static bool
+tkt_q_init_contend(int i, arch_spinlock_t *asp, struct __raw_tickets inc)
+{
+	arch_spinlock_t asold;
+	arch_spinlock_t asnew;
+	struct tkt_q_head *tqhp;
+
+	/* Initialize the i-th queue header. */
+	tqhp = &tkt_q_heads[i];
+	tqhp->spin = NULL;
+	tqhp->spin_tail = &tqhp->spin;
+
+	/* Each pass through this loop attempts to mark the lock as queued. */
+	do {
+		asold.head_tail = ACCESS_ONCE(asp->head_tail);
+		asnew = asold;
+		if (asnew.tickets.head & 0x1) {
+
+			/* Someone beat us to it, back out. */
+			smp_mb();
+			ACCESS_ONCE(tqhp->ref) = NULL;
+
+			/* Spin on the queue element they set up. */
+			return tkt_q_do_spin(asp, inc);
+		}
+
+		/* The low-order bit in the head counter says "queued". */
+		asnew.tickets.head |= 0x1;
+	} while (cmpxchg(&asp->head_tail,
+		 asold.head_tail,
+		 asnew.head_tail) != asold.head_tail);
+
+	/* Point the queue at the lock and go spin on it. */
+	tqhp->head_tkt = asold.tickets.head;
+	smp_mb(); /* Ensure head_tkt is set prior to queuers seeing tqhp. */
+	ACCESS_ONCE(tqhp->ref) = asp;
+	return tkt_q_do_spin(asp, inc);
+}
+
+/*
+ * Start handling a period of high contention by finding a queue to associate
+ * with this lock.  Returns true if successful (in which case we hold the
+ * lock) and false otherwise (in which case we do -not- hold the lock).
+ */
+bool tkt_q_start_contend(arch_spinlock_t *asp, struct __raw_tickets inc)
+{
+	int i;
+	int start;
+
+	/* Hash the lock address to find a starting point. */
+	start = i = tkt_q_hash(asp);
+
+	/*
+	 * Each pass through the following loop attempts to associate
+	 * the lock with the corresponding queue.
+	 */
+	do {
+		/*
+		 * Use 0x1 to mark the queue in use, but also avoiding
+		 * any spinners trying to use it before we get it all
+		 * initialized.
+		 */
+		if (cmpxchg(&tkt_q_heads[i].ref,
+			    NULL,
+			    (arch_spinlock_t *)0x1) == NULL) {
+
+			/* Succeeded, now go initialize it. */
+			return tkt_q_init_contend(i, asp, inc);
+		}
+
+		/* If someone beat us to it, go spin on their queue. */
+		if (ACCESS_ONCE(asp->tickets.head) & 0x1)
+			return tkt_q_do_spin(asp, inc);
+	} while ((i = tkt_q_next_slot(i)) != start);
+
+	/* All the queues are in use, revert to spinning on the ticket lock. */
+	return false;
+}
+
+bool tkt_spin_pass(arch_spinlock_t *ap, struct __raw_tickets inc)
+{
+	if (unlikely(inc.head & 0x1)) {
+
+		/* This lock has a queue, so go spin on the queue. */
+		if (tkt_q_do_spin(ap, inc))
+			return true;
+
+		/* Get here if the queue is in transition: Retry next time. */
+
+	} else if (TICKET_T_CMP_GE(ACCESS_ONCE(ap->tickets.tail) - TKT_Q_SWITCH,
+				   ACCESS_ONCE(ap->tickets.head))) {
+
+		/*
+		 * This lock has lots of spinners, but no queue.
+		 * Go create a queue to spin on.
+		 */
+		if (tkt_q_start_contend(ap, inc))
+			return true;
+
+		/* Get here if the queue is in transition: Retry next time. */
+	}
+
+	/* Either no need for a queue or the queue is in transition.  Spin. */
+	cpu_relax();
+	return false;
+}

Quoted 337 lines · Paul E. McKenney

arch/x86/include/asm/spinlock.h +39 -0

+#else /* #ifndef CONFIG_TICKET_LOCK_QUEUED */
+
+bool tkt_spin_pass(arch_spinlock_t *ap, struct __raw_tickets inc);
+
+static __always_inline void __ticket_spin_lock(arch_spinlock_t *lock)
+{
+	register struct __raw_tickets inc = { .tail = 2 };
+
+	inc = xadd(&lock->tickets, inc);
+	for (;;) {
+		if (inc.head == inc.tail || tkt_spin_pass(lock, inc))
+			break;
+		inc.head = ACCESS_ONCE(lock->tickets.head);
+	}
+	barrier(); /* smp_mb() on Power or ARM. */
+}
+
+#endif /* #else #ifndef CONFIG_TICKET_LOCK_QUEUED */
+
 static __always_inline int __ticket_spin_trylock(arch_spinlock_t *lock)
 {
 	arch_spinlock_t old, new;

@@ -70,17 +91,37 @@ static __always_inline int __ticket_spin_trylock(arch_spinlock_t *lock)
 	if (old.tickets.head != old.tickets.tail)
 		return 0;
 
+#ifndef CONFIG_TICKET_LOCK_QUEUED
 	new.head_tail = old.head_tail + (1 << TICKET_SHIFT);
+#else /* #ifndef CONFIG_TICKET_LOCK_QUEUED */
+	new.head_tail = old.head_tail + (2 << TICKET_SHIFT);
+#endif /* #else #ifndef CONFIG_TICKET_LOCK_QUEUED */
 
 	/* cmpxchg is a full barrier, so nothing can move before it */
 	return cmpxchg(&lock->head_tail, old.head_tail, new.head_tail) == old.head_tail;
 }
 
+#ifndef CONFIG_TICKET_LOCK_QUEUED
+
 static __always_inline void __ticket_spin_unlock(arch_spinlock_t *lock)
 {
 	__add(&lock->tickets.head, 1, UNLOCK_LOCK_PREFIX);
 }
 
+#else /* #ifndef CONFIG_TICKET_LOCK_QUEUED */
+
+extern void tkt_q_do_wake(arch_spinlock_t *asp);
+
+static __always_inline void __ticket_spin_unlock(arch_spinlock_t *lock)
+{
+	__ticket_t head = 2;
+
+	head = xadd(&lock->tickets.head, 2);
+	if (head & 0x1)
+		tkt_q_do_wake(lock);
+}
+#endif /* #else #ifndef CONFIG_TICKET_LOCK_QUEUED */
+
 static inline int __ticket_spin_is_locked(arch_spinlock_t *lock)
 {
 	struct __raw_tickets tmp = ACCESS_ONCE(lock->tickets);

arch/x86/include/asm/spinlock_types.h +12 -2

index ad0ad07..cdaefdd 100644
@@ -7,12 +7,18 @@
 
 #include <linux/types.h>
 
-#if (CONFIG_NR_CPUS < 256)
+#if (CONFIG_NR_CPUS < 128)
 typedef u8  __ticket_t;
 typedef u16 __ticketpair_t;
-#else
+#define TICKET_T_CMP_GE(a, b) (UCHAR_MAX / 2 >= (unsigned char)((a) - (b)))
+#elif (CONFIG_NR_CPUS < 32768)
 typedef u16 __ticket_t;
 typedef u32 __ticketpair_t;
+#define TICKET_T_CMP_GE(a, b) (USHRT_MAX / 2 >= (unsigned short)((a) - (b)))
+#else
+typedef u32 __ticket_t;
+typedef u64 __ticketpair_t;
+#define TICKET_T_CMP_GE(a, b) (UINT_MAX / 2 >= (unsigned int)((a) - (b)))
 #endif
 
 #define TICKET_SHIFT	(sizeof(__ticket_t) * 8)

@@ -21,7 +27,11 @@ typedef struct arch_spinlock {
 	union {
 		__ticketpair_t head_tail;
 		struct __raw_tickets {
+#ifdef __BIG_ENDIAN__
+			__ticket_t tail, head;
+#else /* #ifdef __BIG_ENDIAN__ */
 			__ticket_t head, tail;
+#endif /* #else #ifdef __BIG_ENDIAN__ */
 		} tickets;
 	};
 } arch_spinlock_t;

include/linux/kernel.h +1 -0

index e9ef6d6..816a87c 100644
@@ -15,6 +15,7 @@
 #include <asm/byteorder.h>
 #include <uapi/linux/kernel.h>
 
+#define UCHAR_MAX	((u8)(~0U))
 #define USHRT_MAX	((u16)(~0U))
 #define SHRT_MAX	((s16)(USHRT_MAX>>1))
 #define SHRT_MIN	((s16)(-SHRT_MAX - 1))

kernel/Kconfig.locks +18 -0

index 44511d1..ad9c67c 100644
@@ -223,3 +223,21 @@ endif
 config MUTEX_SPIN_ON_OWNER
 	def_bool y
 	depends on SMP && !DEBUG_MUTEXES
+
+config TICKET_LOCK_QUEUED
+	bool "Dynamically switch between ticket and queued locking"
+	default n
+	---help---
+	  Enable dynamic switching between ticketlock and queued locking
+	  on a per-lock basis.  This option will slow down low-contention
+	  acquisition and release very slightly (additional conditional
+	  in release path), but will provide more efficient operation at
+	  high levels of lock contention.  High-contention operation will
+	  not be quite as efficient as would be a pure queued lock, but
+	  this dynamic approach consumes less memory than queud locks
+	  and also runs faster at low levels of contention.
+
+	  Say "Y" if you are running on a large system with a workload
+	  that is likely to result in high levels of contention.
+
+	  Say "N" if you are unsure.

kernel/Makefile +1 -0

index 271fd31..70a91f7 100644
@@ -51,6 +51,7 @@ endif
 obj-$(CONFIG_SMP) += spinlock.o
 obj-$(CONFIG_DEBUG_SPINLOCK) += spinlock.o
 obj-$(CONFIG_PROVE_LOCKING) += spinlock.o
+obj-$(CONFIG_TICKET_LOCK_QUEUED) += tktqlock.o
 obj-$(CONFIG_UID16) += uid16.o
 obj-$(CONFIG_MODULES) += module.o
 obj-$(CONFIG_MODULE_SIG) += module_signing.o modsign_pubkey.o modsign_certificate.o

kernel/tktqlock.c new file +184 -0

new file mode 100644
index 0000000..f01b760
@@ -0,0 +1,333 @@
+/*
+ * Queued ticket spinlocks.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * Copyright IBM Corporation, 2013
+ *
+ * Authors: Paul E. McKenney <[email protected]>
+ */
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/spinlock.h>
+#include <linux/smp.h>
+#include <linux/percpu.h>
+
+struct tkt_q {
+	int cpu;
+	__ticket_t tail;
+	struct tkt_q *next;
+};
+
+struct tkt_q_head {
+	arch_spinlock_t *ref;		/* Pointer to spinlock if in use. */
+	s32 head_tkt;			/* Head ticket when started queuing. */
+	struct tkt_q *spin;		/* Head of queue. */
+	struct tkt_q **spin_tail;	/* Tail of queue. */
+};
+
+/*
+ * TKT_Q_SWITCH is twice the number of CPUs that must be spinning on a
+ * given ticket lock to motivate switching to spinning on a queue.
+ * The reason that it is twice the number is because the bottom bit of
+ * the ticket is reserved for the bit that indicates that a queue is
+ * associated with the lock.
+ */
+#define TKT_Q_SWITCH  (16 * 2)
+
+/*
+ * TKT_Q_NQUEUES is the number of queues to maintain.  Large systems
+ * might have multiple highly contended locks, so provide more queues for
+ * systems with larger numbers of CPUs.
+ */
+#define TKT_Q_NQUEUES (DIV_ROUND_UP(NR_CPUS + TKT_Q_SWITCH - 1, TKT_Q_SWITCH) * 2)
+
+/* The queues themselves. */
+struct tkt_q_head tkt_q_heads[TKT_Q_NQUEUES];
+
+/* Advance to the next queue slot, wrapping around to the beginning. */
+static int tkt_q_next_slot(int i)
+{
+	return (++i < TKT_Q_NQUEUES) ? i : 0;
+}
+
+/* Very crude hash from lock address to queue slot number. */
+static unsigned long tkt_q_hash(arch_spinlock_t *asp)
+{
+	return (((unsigned long)asp) >> 8) % TKT_Q_NQUEUES;
+}
+
+/*
+ * Return a pointer to the queue header associated with the specified lock,
+ * or return NULL if there is no queue for the lock or if the lock's queue
+ * is in transition.
+ */
+static struct tkt_q_head *tkt_q_find_head(arch_spinlock_t *asp)
+{
+	int i;
+	int start;
+
+	start = i = tkt_q_hash(asp);
+	do
+		if (tkt_q_heads[i].ref == asp)
+			return &tkt_q_heads[i];
+	while ((i = tkt_q_next_slot(i)) != start);
+	return NULL;
+}
+
+/*
+ * Try to stop queuing, reverting back to normal ticket-lock operation.
+ * We can only stop queuing when the queue is empty, which means that
+ * we need to correctly handle races where someone shows up in the queue
+ * just as we are trying to dispense with the queue.  They win, we lose.
+ */
+static bool tkt_q_try_unqueue(arch_spinlock_t *asp, struct tkt_q_head *tqhp)
+{
+	arch_spinlock_t asold;
+	arch_spinlock_t asnew;
+
+	/* Pick up the ticket values. */
+	asold = ACCESS_ONCE(*asp);
+	if ((asold.tickets.head & ~0x1) == asold.tickets.tail) {
+
+		/* Attempt to mark the lock as not having a queue. */
+		asnew = asold;
+		asnew.tickets.head &= ~0x1;
+		if (cmpxchg(&asp->head_tail,
+			    asold.head_tail,
+			    asnew.head_tail) == asold.head_tail) {
+
+			/* Succeeded, mark the queue as unused. */
+			ACCESS_ONCE(tqhp->ref) = NULL;
+			return true;
+		}
+	}
+
+	/* Failed, tell the caller there is still a queue to pass off to. */
+	return false;
+}
+
+/*
+ * Hand the lock off to the first CPU on the queue.
+ */
+void tkt_q_do_wake(arch_spinlock_t *asp)
+{
+	struct tkt_q_head *tqhp;
+	struct tkt_q *tqp;
+
+	/* If the queue is still being set up, wait for it. */
+	while ((tqhp = tkt_q_find_head(asp)) == NULL)
+		cpu_relax();
+
+	for (;;) {
+
+		/* Find the first queue element. */
+		tqp = ACCESS_ONCE(tqhp->spin);
+		if (tqp != NULL)
+			break;  /* Element exists, hand off lock. */
+		if (tkt_q_try_unqueue(asp, tqhp))
+			return; /* No element, successfully removed queue. */
+		cpu_relax();
+	}
+	if (ACCESS_ONCE(tqhp->head_tkt) != -1)
+		ACCESS_ONCE(tqhp->head_tkt) = -1;
+	smp_mb(); /* Order pointer fetch and assignment against handoff. */
+	ACCESS_ONCE(tqp->cpu) = -1;
+}
+
+/*
+ * Given a lock that already has a queue associated with it, spin on
+ * that queue.  Return false if there was no queue (which means we do not
+ * hold the lock) and true otherwise (meaning we -do- hold the lock).
+ */
+bool tkt_q_do_spin(arch_spinlock_t *asp, struct __raw_tickets inc)
+{
+	struct tkt_q **oldtail;
+	struct tkt_q tq;
+	struct tkt_q_head *tqhp;
+
+	/*
+	 * Ensure that accesses to queue header happen after sensing
+	 * the lock's have-queue bit.
+	 */
+	smp_mb();  /* See above block comment. */
+
+	/* If there no longer is a queue, leave. */
+	tqhp = tkt_q_find_head(asp);
+	if (tqhp == NULL)
+		return false;
+
+	/* Initialize our queue element. */
+	tq.cpu = raw_smp_processor_id();
+	tq.tail = inc.tail;
+	tq.next = NULL;
+
+	/* Check to see if we already hold the lock. */
+	if (ACCESS_ONCE(tqhp->head_tkt) == inc.tail) {
+		/* The last holder left before queue formed, we hold lock. */
+		tqhp->head_tkt = -1;
+		return true;
+	}
+
+	/* Add our element to the tail of the queue. */

kernel/tktqlock.c line 185

Quoted 1 line

kernel/tktqlock.c new file +1 -0

+	oldtail = xchg(&tqhp->spin_tail, &tq.next);

Boy this is tricky code! I thought I found a race window here, but as I went to write my email saying "Gotcha!" I found that it wasn't a race after all. But as I went though the effort of writing this, I figured I would send this out as documentation for others to see. Hmm, I wonder if we can use this email to add more comments. Anyway, here's what I thought was wrong ;-)

OK, I originally thought there was a race window here. Let's say that an NMI hit right here, and it happens to be a big one, where lots of things can happen on other CPUs right now.

The scenario is that there's just one item on the queue, which is waiting for the lock to be released, and is spinning below in the:

	while (ACCESS_ONCE(tq.cpu) != -1)
		cpu_relax();

And then the lock is released, where in tkt_q_do_wake() the following is called:

	ACCESS_ONCE(tqp->cpu) = -1;

Now the old queued task is released. But it's tq->next hasn't been set yet, and is still NULL. It leaves by doing:

	ACCESS_ONCE(tqhp->spin) = tq.next;
	return true;

All before this task gets to set *oldtail to &tq. But, I then looked below...

kernel/tktqlock.c line 197

Quoted 12 lines

kernel/tktqlock.c new file +12 -0

+	ACCESS_ONCE(*oldtail) = &tq;
+
+	/* Spin until handoff. */
+	while (ACCESS_ONCE(tq.cpu) != -1)
+		cpu_relax();
+
+	/*
+	 * Remove our element from the queue.  If the queue is now empty,
+	 * update carefully so that the next acquisition will queue itself
+	 * at the head of the list.
+	 */
+	if (tq.next == NULL) {

This checks for that scenario.

As if the old task were to come out
spinning, the problem would only be if it was the last one on the list, and its tq.next was NULL. But if that was the case, then we set spin to NULL and do the next trick, where I thought I gotcha again...

kernel/tktqlock.c line 205

Quoted 8 lines

kernel/tktqlock.c new file +8 -0

+
+		/* Mark the queue empty. */
+		tqhp->spin = NULL;
+
+		/* Try to point the tail back at the head. */
+		if (cmpxchg(&tqhp->spin_tail,
+			    &tq.next,
+			    &tqhp->spin) == &tq.next)

Here, I was thinking, oh wait, what happens if this is called right before the xchg() above. Then we would set spin_tail but not update the old tq.next. But wait! look at what we assign spin_tail to. It's the address of spin, which would be what oldtail would point to above, and then above would set spin to the new tq!

OK, I haven't found a issue here yet, but youss are beiing trickssy! We don't like trickssy, and we must find precccciouss!!!

This code is starting to make me look like Gollum :-p

-- Steve

Quoted 128 lines

kernel/tktqlock.c new file +128 -0

+			return true; /* Succeeded, queue is now empty. */
+
+		/* Failed, if needed, wait for the enqueue to complete. */
+		while (tq.next == NULL)
+			cpu_relax();
+
+		/* The following code will repair the head. */
+	}
+	smp_mb(); /* Force ordering between handoff and critical section. */
+
+	/* Advance list-head pointer. */
+	ACCESS_ONCE(tqhp->spin) = tq.next;
+	return true;
+}
+
+/*
+ * Given a lock that does not have a queue, attempt to associate the
+ * i-th queue with it, returning true if successful (meaning we hold
+ * the lock) or false otherwise (meaning we do -not- hold the lock).
+ * Note that the caller has already filled in ->ref with 0x1, so we
+ * own the queue.
+ */
+static bool
+tkt_q_init_contend(int i, arch_spinlock_t *asp, struct __raw_tickets inc)
+{
+	arch_spinlock_t asold;
+	arch_spinlock_t asnew;
+	struct tkt_q_head *tqhp;
+
+	/* Initialize the i-th queue header. */
+	tqhp = &tkt_q_heads[i];
+	tqhp->spin = NULL;
+	tqhp->spin_tail = &tqhp->spin;
+
+	/* Each pass through this loop attempts to mark the lock as queued. */
+	do {
+		asold.head_tail = ACCESS_ONCE(asp->head_tail);
+		asnew = asold;
+		if (asnew.tickets.head & 0x1) {
+
+			/* Someone beat us to it, back out. */
+			smp_mb();
+			ACCESS_ONCE(tqhp->ref) = NULL;
+
+			/* Spin on the queue element they set up. */
+			return tkt_q_do_spin(asp, inc);
+		}
+
+		/* The low-order bit in the head counter says "queued". */
+		asnew.tickets.head |= 0x1;
+	} while (cmpxchg(&asp->head_tail,
+		 asold.head_tail,
+		 asnew.head_tail) != asold.head_tail);
+
+	/* Point the queue at the lock and go spin on it. */
+	tqhp->head_tkt = asold.tickets.head;
+	smp_mb(); /* Ensure head_tkt is set prior to queuers seeing tqhp. */
+	ACCESS_ONCE(tqhp->ref) = asp;
+	return tkt_q_do_spin(asp, inc);
+}
+
+/*
+ * Start handling a period of high contention by finding a queue to associate
+ * with this lock.  Returns true if successful (in which case we hold the
+ * lock) and false otherwise (in which case we do -not- hold the lock).
+ */
+bool tkt_q_start_contend(arch_spinlock_t *asp, struct __raw_tickets inc)
+{
+	int i;
+	int start;
+
+	/* Hash the lock address to find a starting point. */
+	start = i = tkt_q_hash(asp);
+
+	/*
+	 * Each pass through the following loop attempts to associate
+	 * the lock with the corresponding queue.
+	 */
+	do {
+		/*
+		 * Use 0x1 to mark the queue in use, but also avoiding
+		 * any spinners trying to use it before we get it all
+		 * initialized.
+		 */
+		if (cmpxchg(&tkt_q_heads[i].ref,
+			    NULL,
+			    (arch_spinlock_t *)0x1) == NULL) {
+
+			/* Succeeded, now go initialize it. */
+			return tkt_q_init_contend(i, asp, inc);
+		}
+
+		/* If someone beat us to it, go spin on their queue. */
+		if (ACCESS_ONCE(asp->tickets.head) & 0x1)
+			return tkt_q_do_spin(asp, inc);
+	} while ((i = tkt_q_next_slot(i)) != start);
+
+	/* All the queues are in use, revert to spinning on the ticket lock. */
+	return false;
+}
+
+bool tkt_spin_pass(arch_spinlock_t *ap, struct __raw_tickets inc)
+{
+	if (unlikely(inc.head & 0x1)) {
+
+		/* This lock has a queue, so go spin on the queue. */
+		if (tkt_q_do_spin(ap, inc))
+			return true;
+
+		/* Get here if the queue is in transition: Retry next time. */
+
+	} else if (TICKET_T_CMP_GE(ACCESS_ONCE(ap->tickets.tail) - TKT_Q_SWITCH,
+				   ACCESS_ONCE(ap->tickets.head))) {
+
+		/*
+		 * This lock has lots of spinners, but no queue.
+		 * Go create a queue to spin on.
+		 */
+		if (tkt_q_start_contend(ap, inc))
+			return true;
+
+		/* Get here if the queue is in transition: Retry next time. */
+	}
+
+	/* Either no need for a queue or the queue is in transition.  Spin. */
+	cpu_relax();
+	return false;
+}

Quoted 3 lines · Steven Rostedt

OK, I haven't found a issue here yet, but youss are beiing trickssy! We don't like trickssy, and we must find precccciouss!!!

.. and I personally have my usual reservations. I absolutely hate papering over scalability issues, and historically whenever people have ever thought that we want complex spinlocks, the problem has always been that the locking sucks.

So reinforced by previous events, I really feel that code that needs this kind of spinlock is broken and needs to be fixed, rather than actually introduce tricky spinlocks.

So in order to merge something like this, I want (a) numbers for real loads and (b) explanations for why the spinlock users cannot be fixed.

Because "we might hit loads" is just not good enough. I would counter with "hiding problems causes more of them".

Quoted 14 lines · Linus Torvalds

Quoted 3 lines · Steven Rostedt

OK, I haven't found a issue here yet, but youss are beiing trickssy! We don't like trickssy, and we must find precccciouss!!!

.. and I personally have my usual reservations. I absolutely hate papering over scalability issues, and historically whenever people have ever thought that we want complex spinlocks, the problem has always been that the locking sucks.

So reinforced by previous events, I really feel that code that needs this kind of spinlock is broken and needs to be fixed, rather than actually introduce tricky spinlocks.

Quoted 6 lines

So in order to merge something like this, I want (a) numbers for real loads and (b) explanations for why the spinlock users cannot be fixed.

Because "we might hit loads" is just not good enough. I would counter with "hiding problems causes more of them".

Hi, all

Off-topic, although I am in this community for several years, I am not exactly clear with this problem.

1) In general case, which lock is the most competitive in the kernel? what it protects for?
2) In which special case, which lock is the most competitive in the kernel? what it protects for?
3) In general case, which list is the most hot list?
4) In which special case, which list is the most hot list?

Breaking up locks is better than implementing high-contention locks, but if we must have high-contention locks, why not make them automatically switch between light-weight ticket locks at low contention and queued locks at high contention?

This commit therefore allows ticket locks to automatically switch between pure ticketlock and queued-lock operation as needed. If too many CPUs are spinning on a given ticket lock, a queue structure will be allocated and the lock will switch to queued-lock operation. When the lock becomes free, it will switch back into ticketlock operation. The low-order bit of the head counter is used to indicate that the lock is in queued mode, which forces an unconditional mismatch between the head and tail counters. This approach means that the common-case code path under conditions of low contention is very nearly that of a plain ticket lock.

A fixed number of queueing structures is statically allocated in an array. The ticket-lock address is used to hash into an initial element, but if that element is already in use, it moves to the next element. If the entire array is already in use, continue to spin in ticket mode.

This has been only lightly tested in the kernel, though a userspace implementation has survived substantial testing.

Signed-off-by Paul E. McKenney <[email protected]>

arch/x86/include/asm/spinlock.h +41 -0

index 33692ea..b4a91b0 100644
@@ -34,6 +34,8 @@
 # define UNLOCK_LOCK_PREFIX
 #endif
 
+#ifndef CONFIG_TICKET_LOCK_QUEUED
+
 /*
  * Ticket locks are conceptually two parts, one indicating the current head of
  * the queue, and the other indicating the current tail. The lock is acquired

@@ -62,6 +64,25 @@ static __always_inline void __ticket_spin_lock(arch_spinlock_t *lock)
        barrier();              /* make sure nothing creeps before the lock is taken */
 }
 
+#else /* #ifndef CONFIG_TICKET_LOCK_QUEUED */
+
+bool tkt_spin_pass(arch_spinlock_t *ap, struct __raw_tickets inc);
+
+static __always_inline void __ticket_spin_lock(arch_spinlock_t *lock)
+{
+       register struct __raw_tickets inc = { .tail = 2 };
+
+       inc = xadd(&lock->tickets, inc);
+       for (;;) {
+               if (inc.head == inc.tail || tkt_spin_pass(lock, inc))
+                       break;
+               inc.head = ACCESS_ONCE(lock->tickets.head);
+       }
+       barrier(); /* smp_mb() on Power or ARM. */
+}
+
+#endif /* #else #ifndef CONFIG_TICKET_LOCK_QUEUED */
+
 static __always_inline int __ticket_spin_trylock(arch_spinlock_t *lock)
 {
        arch_spinlock_t old, new;

@@ -70,17 +91,37 @@ static __always_inline int __ticket_spin_trylock(arch_spinlock_t *lock)
        if (old.tickets.head != old.tickets.tail)
                return 0;
 
+#ifndef CONFIG_TICKET_LOCK_QUEUED
        new.head_tail = old.head_tail + (1 << TICKET_SHIFT);
+#else /* #ifndef CONFIG_TICKET_LOCK_QUEUED */
+       new.head_tail = old.head_tail + (2 << TICKET_SHIFT);
+#endif /* #else #ifndef CONFIG_TICKET_LOCK_QUEUED */
 
        /* cmpxchg is a full barrier, so nothing can move before it */
        return cmpxchg(&lock->head_tail, old.head_tail, new.head_tail) == old.head_tail;
 }
 
+#ifndef CONFIG_TICKET_LOCK_QUEUED
+
 static __always_inline void __ticket_spin_unlock(arch_spinlock_t *lock)
 {
        __add(&lock->tickets.head, 1, UNLOCK_LOCK_PREFIX);
 }
 
+#else /* #ifndef CONFIG_TICKET_LOCK_QUEUED */
+
+extern void tkt_q_do_wake(arch_spinlock_t *asp);
+
+static __always_inline void __ticket_spin_unlock(arch_spinlock_t *lock)
+{
+       __ticket_t head = 2;
+
+       head = xadd(&lock->tickets.head, 2);
+       if (head & 0x1)
+               tkt_q_do_wake(lock);
+}
+#endif /* #else #ifndef CONFIG_TICKET_LOCK_QUEUED */
+
 static inline int __ticket_spin_is_locked(arch_spinlock_t *lock)
 {
        struct __raw_tickets tmp = ACCESS_ONCE(lock->tickets);

arch/x86/include/asm/spinlock_types.h +12 -2

index ad0ad07..cdaefdd 100644
@@ -7,12 +7,18 @@
 
 #include <linux/types.h>
 
-#if (CONFIG_NR_CPUS < 256)
+#if (CONFIG_NR_CPUS < 128)
 typedef u8  __ticket_t;
 typedef u16 __ticketpair_t;
-#else
+#define TICKET_T_CMP_GE(a, b) (UCHAR_MAX / 2 >= (unsigned char)((a) - (b)))
+#elif (CONFIG_NR_CPUS < 32768)
 typedef u16 __ticket_t;
 typedef u32 __ticketpair_t;
+#define TICKET_T_CMP_GE(a, b) (USHRT_MAX / 2 >= (unsigned short)((a) - (b)))
+#else
+typedef u32 __ticket_t;
+typedef u64 __ticketpair_t;
+#define TICKET_T_CMP_GE(a, b) (UINT_MAX / 2 >= (unsigned int)((a) - (b)))
 #endif
 
 #define TICKET_SHIFT   (sizeof(__ticket_t) * 8)

@@ -21,7 +27,11 @@ typedef struct arch_spinlock {
        union {
                __ticketpair_t head_tail;
                struct __raw_tickets {
+#ifdef __BIG_ENDIAN__
+                       __ticket_t tail, head;
+#else /* #ifdef __BIG_ENDIAN__ */
                        __ticket_t head, tail;
+#endif /* #else #ifdef __BIG_ENDIAN__ */
                } tickets;
        };
 } arch_spinlock_t;

include/linux/kernel.h +1 -0

index e9ef6d6..816a87c 100644
@@ -15,6 +15,7 @@
 #include <asm/byteorder.h>
 #include <uapi/linux/kernel.h>
 
+#define UCHAR_MAX      ((u8)(~0U))
 #define USHRT_MAX      ((u16)(~0U))
 #define SHRT_MAX       ((s16)(USHRT_MAX>>1))
 #define SHRT_MIN       ((s16)(-SHRT_MAX - 1))

kernel/Kconfig.locks +18 -0

index 44511d1..ad9c67c 100644
@@ -223,3 +223,21 @@ endif
 config MUTEX_SPIN_ON_OWNER
        def_bool y
        depends on SMP && !DEBUG_MUTEXES
+
+config TICKET_LOCK_QUEUED
+       bool "Dynamically switch between ticket and queued locking"
+       default n
+       ---help---
+         Enable dynamic switching between ticketlock and queued locking
+         on a per-lock basis.  This option will slow down low-contention
+         acquisition and release very slightly (additional conditional
+         in release path), but will provide more efficient operation at
+         high levels of lock contention.  High-contention operation will
+         not be quite as efficient as would be a pure queued lock, but
+         this dynamic approach consumes less memory than queud locks
+         and also runs faster at low levels of contention.
+
+         Say "Y" if you are running on a large system with a workload
+         that is likely to result in high levels of contention.
+
+         Say "N" if you are unsure.

kernel/Makefile +1 -0

index 271fd31..70a91f7 100644
@@ -51,6 +51,7 @@ endif
 obj-$(CONFIG_SMP) += spinlock.o
 obj-$(CONFIG_DEBUG_SPINLOCK) += spinlock.o
 obj-$(CONFIG_PROVE_LOCKING) += spinlock.o
+obj-$(CONFIG_TICKET_LOCK_QUEUED) += tktqlock.o
 obj-$(CONFIG_UID16) += uid16.o
 obj-$(CONFIG_MODULES) += module.o
 obj-$(CONFIG_MODULE_SIG) += module_signing.o modsign_pubkey.o modsign_certificate.o

kernel/tktqlock.c new file +255 -0

new file mode 100644
index 0000000..f01b760
@@ -0,0 +1,333 @@
+/*
+ * Queued ticket spinlocks.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * Copyright IBM Corporation, 2013
+ *
+ * Authors: Paul E. McKenney <[email protected]>
+ */
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/spinlock.h>
+#include <linux/smp.h>
+#include <linux/percpu.h>
+
+struct tkt_q {
+       int cpu;
+       __ticket_t tail;
+       struct tkt_q *next;
+};
+
+struct tkt_q_head {
+       arch_spinlock_t *ref;           /* Pointer to spinlock if in use. */
+       s32 head_tkt;                   /* Head ticket when started queuing. */
+       struct tkt_q *spin;             /* Head of queue. */
+       struct tkt_q **spin_tail;       /* Tail of queue. */
+};
+
+/*
+ * TKT_Q_SWITCH is twice the number of CPUs that must be spinning on a
+ * given ticket lock to motivate switching to spinning on a queue.
+ * The reason that it is twice the number is because the bottom bit of
+ * the ticket is reserved for the bit that indicates that a queue is
+ * associated with the lock.
+ */
+#define TKT_Q_SWITCH  (16 * 2)
+
+/*
+ * TKT_Q_NQUEUES is the number of queues to maintain.  Large systems
+ * might have multiple highly contended locks, so provide more queues for
+ * systems with larger numbers of CPUs.
+ */
+#define TKT_Q_NQUEUES (DIV_ROUND_UP(NR_CPUS + TKT_Q_SWITCH - 1, TKT_Q_SWITCH) * 2)
+
+/* The queues themselves. */
+struct tkt_q_head tkt_q_heads[TKT_Q_NQUEUES];
+
+/* Advance to the next queue slot, wrapping around to the beginning. */
+static int tkt_q_next_slot(int i)
+{
+       return (++i < TKT_Q_NQUEUES) ? i : 0;
+}
+
+/* Very crude hash from lock address to queue slot number. */
+static unsigned long tkt_q_hash(arch_spinlock_t *asp)
+{
+       return (((unsigned long)asp) >> 8) % TKT_Q_NQUEUES;
+}
+
+/*
+ * Return a pointer to the queue header associated with the specified lock,
+ * or return NULL if there is no queue for the lock or if the lock's queue
+ * is in transition.
+ */
+static struct tkt_q_head *tkt_q_find_head(arch_spinlock_t *asp)
+{
+       int i;
+       int start;
+
+       start = i = tkt_q_hash(asp);
+       do
+               if (tkt_q_heads[i].ref == asp)
+                       return &tkt_q_heads[i];
+       while ((i = tkt_q_next_slot(i)) != start);
+       return NULL;
+}
+
+/*
+ * Try to stop queuing, reverting back to normal ticket-lock operation.
+ * We can only stop queuing when the queue is empty, which means that
+ * we need to correctly handle races where someone shows up in the queue
+ * just as we are trying to dispense with the queue.  They win, we lose.
+ */
+static bool tkt_q_try_unqueue(arch_spinlock_t *asp, struct tkt_q_head *tqhp)
+{
+       arch_spinlock_t asold;
+       arch_spinlock_t asnew;
+
+       /* Pick up the ticket values. */
+       asold = ACCESS_ONCE(*asp);
+       if ((asold.tickets.head & ~0x1) == asold.tickets.tail) {
+
+               /* Attempt to mark the lock as not having a queue. */
+               asnew = asold;
+               asnew.tickets.head &= ~0x1;
+               if (cmpxchg(&asp->head_tail,
+                           asold.head_tail,
+                           asnew.head_tail) == asold.head_tail) {
+
+                       /* Succeeded, mark the queue as unused. */
+                       ACCESS_ONCE(tqhp->ref) = NULL;
+                       return true;
+               }
+       }
+
+       /* Failed, tell the caller there is still a queue to pass off to. */
+       return false;
+}
+
+/*
+ * Hand the lock off to the first CPU on the queue.
+ */
+void tkt_q_do_wake(arch_spinlock_t *asp)
+{
+       struct tkt_q_head *tqhp;
+       struct tkt_q *tqp;
+
+       /* If the queue is still being set up, wait for it. */
+       while ((tqhp = tkt_q_find_head(asp)) == NULL)
+               cpu_relax();
+
+       for (;;) {
+
+               /* Find the first queue element. */
+               tqp = ACCESS_ONCE(tqhp->spin);
+               if (tqp != NULL)
+                       break;  /* Element exists, hand off lock. */
+               if (tkt_q_try_unqueue(asp, tqhp))
+                       return; /* No element, successfully removed queue. */
+               cpu_relax();
+       }
+       if (ACCESS_ONCE(tqhp->head_tkt) != -1)
+               ACCESS_ONCE(tqhp->head_tkt) = -1;
+       smp_mb(); /* Order pointer fetch and assignment against handoff. */
+       ACCESS_ONCE(tqp->cpu) = -1;
+}
+
+/*
+ * Given a lock that already has a queue associated with it, spin on
+ * that queue.  Return false if there was no queue (which means we do not
+ * hold the lock) and true otherwise (meaning we -do- hold the lock).
+ */
+bool tkt_q_do_spin(arch_spinlock_t *asp, struct __raw_tickets inc)
+{
+       struct tkt_q **oldtail;
+       struct tkt_q tq;
+       struct tkt_q_head *tqhp;
+
+       /*
+        * Ensure that accesses to queue header happen after sensing
+        * the lock's have-queue bit.
+        */
+       smp_mb();  /* See above block comment. */
+
+       /* If there no longer is a queue, leave. */
+       tqhp = tkt_q_find_head(asp);
+       if (tqhp == NULL)
+               return false;
+
+       /* Initialize our queue element. */
+       tq.cpu = raw_smp_processor_id();
+       tq.tail = inc.tail;
+       tq.next = NULL;
+
+       /* Check to see if we already hold the lock. */
+       if (ACCESS_ONCE(tqhp->head_tkt) == inc.tail) {
+               /* The last holder left before queue formed, we hold lock. */
+               tqhp->head_tkt = -1;
+               return true;
+       }
+
+       /* Add our element to the tail of the queue. */
+       oldtail = xchg(&tqhp->spin_tail, &tq.next);
+       ACCESS_ONCE(*oldtail) = &tq;
+
+       /* Spin until handoff. */
+       while (ACCESS_ONCE(tq.cpu) != -1)
+               cpu_relax();
+
+       /*
+        * Remove our element from the queue.  If the queue is now empty,
+        * update carefully so that the next acquisition will queue itself
+        * at the head of the list.
+        */
+       if (tq.next == NULL) {
+
+               /* Mark the queue empty. */
+               tqhp->spin = NULL;
+
+               /* Try to point the tail back at the head. */
+               if (cmpxchg(&tqhp->spin_tail,
+                           &tq.next,
+                           &tqhp->spin) == &tq.next)
+                       return true; /* Succeeded, queue is now empty. */
+
+               /* Failed, if needed, wait for the enqueue to complete. */
+               while (tq.next == NULL)
+                       cpu_relax();
+
+               /* The following code will repair the head. */
+       }
+       smp_mb(); /* Force ordering between handoff and critical section. */
+
+       /* Advance list-head pointer. */
+       ACCESS_ONCE(tqhp->spin) = tq.next;
+       return true;
+}
+
+/*
+ * Given a lock that does not have a queue, attempt to associate the
+ * i-th queue with it, returning true if successful (meaning we hold
+ * the lock) or false otherwise (meaning we do -not- hold the lock).
+ * Note that the caller has already filled in ->ref with 0x1, so we
+ * own the queue.
+ */
+static bool
+tkt_q_init_contend(int i, arch_spinlock_t *asp, struct __raw_tickets inc)
+{
+       arch_spinlock_t asold;
+       arch_spinlock_t asnew;
+       struct tkt_q_head *tqhp;
+
+       /* Initialize the i-th queue header. */
+       tqhp = &tkt_q_heads[i];
+       tqhp->spin = NULL;
+       tqhp->spin_tail = &tqhp->spin;
+
+       /* Each pass through this loop attempts to mark the lock as queued. */
+       do {
+               asold.head_tail = ACCESS_ONCE(asp->head_tail);
+               asnew = asold;
+               if (asnew.tickets.head & 0x1) {
+
+                       /* Someone beat us to it, back out. */
+                       smp_mb();
+                       ACCESS_ONCE(tqhp->ref) = NULL;
+
+                       /* Spin on the queue element they set up. */
+                       return tkt_q_do_spin(asp, inc);
+               }
+
+               /* The low-order bit in the head counter says "queued". */
+               asnew.tickets.head |= 0x1;

Quoted 454 lines · Paul E. McKenney

Breaking up locks is better than implementing high-contention locks, but if we must have high-contention locks, why not make them automatically switch between light-weight ticket locks at low contention and queued locks at high contention?

This commit therefore allows ticket locks to automatically switch between pure ticketlock and queued-lock operation as needed. If too many CPUs are spinning on a given ticket lock, a queue structure will be allocated and the lock will switch to queued-lock operation. When the lock becomes free, it will switch back into ticketlock operation. The low-order bit of the head counter is used to indicate that the lock is in queued mode, which forces an unconditional mismatch between the head and tail counters. This approach means that the common-case code path under conditions of low contention is very nearly that of a plain ticket lock.

A fixed number of queueing structures is statically allocated in an array. The ticket-lock address is used to hash into an initial element, but if that element is already in use, it moves to the next element. If the entire array is already in use, continue to spin in ticket mode.

This has been only lightly tested in the kernel, though a userspace implementation has survived substantial testing.

Signed-off-by Paul E. McKenney <[email protected]>

arch/x86/include/asm/spinlock.h +41 -0

index 33692ea..b4a91b0 100644
@@ -34,6 +34,8 @@
 # define UNLOCK_LOCK_PREFIX
 #endif
 
+#ifndef CONFIG_TICKET_LOCK_QUEUED
+
 /*
  * Ticket locks are conceptually two parts, one indicating the current head of
  * the queue, and the other indicating the current tail. The lock is acquired

@@ -62,6 +64,25 @@ static __always_inline void __ticket_spin_lock(arch_spinlock_t *lock)
        barrier();              /* make sure nothing creeps before the lock is taken */
 }
 
+#else /* #ifndef CONFIG_TICKET_LOCK_QUEUED */
+
+bool tkt_spin_pass(arch_spinlock_t *ap, struct __raw_tickets inc);
+
+static __always_inline void __ticket_spin_lock(arch_spinlock_t *lock)
+{
+       register struct __raw_tickets inc = { .tail = 2 };
+
+       inc = xadd(&lock->tickets, inc);
+       for (;;) {
+               if (inc.head == inc.tail || tkt_spin_pass(lock, inc))
+                       break;
+               inc.head = ACCESS_ONCE(lock->tickets.head);
+       }
+       barrier(); /* smp_mb() on Power or ARM. */
+}
+
+#endif /* #else #ifndef CONFIG_TICKET_LOCK_QUEUED */
+
 static __always_inline int __ticket_spin_trylock(arch_spinlock_t *lock)
 {
        arch_spinlock_t old, new;

@@ -70,17 +91,37 @@ static __always_inline int __ticket_spin_trylock(arch_spinlock_t *lock)
        if (old.tickets.head != old.tickets.tail)
                return 0;
 
+#ifndef CONFIG_TICKET_LOCK_QUEUED
        new.head_tail = old.head_tail + (1 << TICKET_SHIFT);
+#else /* #ifndef CONFIG_TICKET_LOCK_QUEUED */
+       new.head_tail = old.head_tail + (2 << TICKET_SHIFT);
+#endif /* #else #ifndef CONFIG_TICKET_LOCK_QUEUED */
 
        /* cmpxchg is a full barrier, so nothing can move before it */
        return cmpxchg(&lock->head_tail, old.head_tail, new.head_tail) == old.head_tail;
 }
 
+#ifndef CONFIG_TICKET_LOCK_QUEUED
+
 static __always_inline void __ticket_spin_unlock(arch_spinlock_t *lock)
 {
        __add(&lock->tickets.head, 1, UNLOCK_LOCK_PREFIX);
 }
 
+#else /* #ifndef CONFIG_TICKET_LOCK_QUEUED */
+
+extern void tkt_q_do_wake(arch_spinlock_t *asp);
+
+static __always_inline void __ticket_spin_unlock(arch_spinlock_t *lock)
+{
+       __ticket_t head = 2;
+
+       head = xadd(&lock->tickets.head, 2);
+       if (head & 0x1)
+               tkt_q_do_wake(lock);
+}
+#endif /* #else #ifndef CONFIG_TICKET_LOCK_QUEUED */
+
 static inline int __ticket_spin_is_locked(arch_spinlock_t *lock)
 {
        struct __raw_tickets tmp = ACCESS_ONCE(lock->tickets);

arch/x86/include/asm/spinlock_types.h +12 -2

index ad0ad07..cdaefdd 100644
@@ -7,12 +7,18 @@
 
 #include <linux/types.h>
 
-#if (CONFIG_NR_CPUS < 256)
+#if (CONFIG_NR_CPUS < 128)
 typedef u8  __ticket_t;
 typedef u16 __ticketpair_t;
-#else
+#define TICKET_T_CMP_GE(a, b) (UCHAR_MAX / 2 >= (unsigned char)((a) - (b)))
+#elif (CONFIG_NR_CPUS < 32768)
 typedef u16 __ticket_t;
 typedef u32 __ticketpair_t;
+#define TICKET_T_CMP_GE(a, b) (USHRT_MAX / 2 >= (unsigned short)((a) - (b)))
+#else
+typedef u32 __ticket_t;
+typedef u64 __ticketpair_t;
+#define TICKET_T_CMP_GE(a, b) (UINT_MAX / 2 >= (unsigned int)((a) - (b)))
 #endif
 
 #define TICKET_SHIFT   (sizeof(__ticket_t) * 8)

@@ -21,7 +27,11 @@ typedef struct arch_spinlock {
        union {
                __ticketpair_t head_tail;
                struct __raw_tickets {
+#ifdef __BIG_ENDIAN__
+                       __ticket_t tail, head;
+#else /* #ifdef __BIG_ENDIAN__ */
                        __ticket_t head, tail;
+#endif /* #else #ifdef __BIG_ENDIAN__ */
                } tickets;
        };
 } arch_spinlock_t;

include/linux/kernel.h +1 -0

index e9ef6d6..816a87c 100644
@@ -15,6 +15,7 @@
 #include <asm/byteorder.h>
 #include <uapi/linux/kernel.h>
 
+#define UCHAR_MAX      ((u8)(~0U))
 #define USHRT_MAX      ((u16)(~0U))
 #define SHRT_MAX       ((s16)(USHRT_MAX>>1))
 #define SHRT_MIN       ((s16)(-SHRT_MAX - 1))

kernel/Kconfig.locks +18 -0

index 44511d1..ad9c67c 100644
@@ -223,3 +223,21 @@ endif
 config MUTEX_SPIN_ON_OWNER
        def_bool y
        depends on SMP && !DEBUG_MUTEXES
+
+config TICKET_LOCK_QUEUED
+       bool "Dynamically switch between ticket and queued locking"
+       default n
+       ---help---
+         Enable dynamic switching between ticketlock and queued locking
+         on a per-lock basis.  This option will slow down low-contention
+         acquisition and release very slightly (additional conditional
+         in release path), but will provide more efficient operation at
+         high levels of lock contention.  High-contention operation will
+         not be quite as efficient as would be a pure queued lock, but
+         this dynamic approach consumes less memory than queud locks
+         and also runs faster at low levels of contention.
+
+         Say "Y" if you are running on a large system with a workload
+         that is likely to result in high levels of contention.
+
+         Say "N" if you are unsure.

kernel/Makefile +1 -0

index 271fd31..70a91f7 100644
@@ -51,6 +51,7 @@ endif
 obj-$(CONFIG_SMP) += spinlock.o
 obj-$(CONFIG_DEBUG_SPINLOCK) += spinlock.o
 obj-$(CONFIG_PROVE_LOCKING) += spinlock.o
+obj-$(CONFIG_TICKET_LOCK_QUEUED) += tktqlock.o
 obj-$(CONFIG_UID16) += uid16.o
 obj-$(CONFIG_MODULES) += module.o
 obj-$(CONFIG_MODULE_SIG) += module_signing.o modsign_pubkey.o modsign_certificate.o

kernel/tktqlock.c new file +259 -0

new file mode 100644
index 0000000..f01b760
@@ -0,0 +1,333 @@
+/*
+ * Queued ticket spinlocks.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * Copyright IBM Corporation, 2013
+ *
+ * Authors: Paul E. McKenney <[email protected]>
+ */
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/spinlock.h>
+#include <linux/smp.h>
+#include <linux/percpu.h>
+
+struct tkt_q {
+       int cpu;
+       __ticket_t tail;
+       struct tkt_q *next;
+};
+
+struct tkt_q_head {
+       arch_spinlock_t *ref;           /* Pointer to spinlock if in use. */
+       s32 head_tkt;                   /* Head ticket when started queuing. */
+       struct tkt_q *spin;             /* Head of queue. */
+       struct tkt_q **spin_tail;       /* Tail of queue. */
+};
+
+/*
+ * TKT_Q_SWITCH is twice the number of CPUs that must be spinning on a
+ * given ticket lock to motivate switching to spinning on a queue.
+ * The reason that it is twice the number is because the bottom bit of
+ * the ticket is reserved for the bit that indicates that a queue is
+ * associated with the lock.
+ */
+#define TKT_Q_SWITCH  (16 * 2)
+
+/*
+ * TKT_Q_NQUEUES is the number of queues to maintain.  Large systems
+ * might have multiple highly contended locks, so provide more queues for
+ * systems with larger numbers of CPUs.
+ */
+#define TKT_Q_NQUEUES (DIV_ROUND_UP(NR_CPUS + TKT_Q_SWITCH - 1, TKT_Q_SWITCH) * 2)
+
+/* The queues themselves. */
+struct tkt_q_head tkt_q_heads[TKT_Q_NQUEUES];
+
+/* Advance to the next queue slot, wrapping around to the beginning. */
+static int tkt_q_next_slot(int i)
+{
+       return (++i < TKT_Q_NQUEUES) ? i : 0;
+}
+
+/* Very crude hash from lock address to queue slot number. */
+static unsigned long tkt_q_hash(arch_spinlock_t *asp)
+{
+       return (((unsigned long)asp) >> 8) % TKT_Q_NQUEUES;
+}
+
+/*
+ * Return a pointer to the queue header associated with the specified lock,
+ * or return NULL if there is no queue for the lock or if the lock's queue
+ * is in transition.
+ */
+static struct tkt_q_head *tkt_q_find_head(arch_spinlock_t *asp)
+{
+       int i;
+       int start;
+
+       start = i = tkt_q_hash(asp);
+       do
+               if (tkt_q_heads[i].ref == asp)
+                       return &tkt_q_heads[i];
+       while ((i = tkt_q_next_slot(i)) != start);
+       return NULL;
+}
+
+/*
+ * Try to stop queuing, reverting back to normal ticket-lock operation.
+ * We can only stop queuing when the queue is empty, which means that
+ * we need to correctly handle races where someone shows up in the queue
+ * just as we are trying to dispense with the queue.  They win, we lose.
+ */
+static bool tkt_q_try_unqueue(arch_spinlock_t *asp, struct tkt_q_head *tqhp)
+{
+       arch_spinlock_t asold;
+       arch_spinlock_t asnew;
+
+       /* Pick up the ticket values. */
+       asold = ACCESS_ONCE(*asp);
+       if ((asold.tickets.head & ~0x1) == asold.tickets.tail) {
+
+               /* Attempt to mark the lock as not having a queue. */
+               asnew = asold;
+               asnew.tickets.head &= ~0x1;
+               if (cmpxchg(&asp->head_tail,
+                           asold.head_tail,
+                           asnew.head_tail) == asold.head_tail) {
+
+                       /* Succeeded, mark the queue as unused. */
+                       ACCESS_ONCE(tqhp->ref) = NULL;
+                       return true;
+               }
+       }
+
+       /* Failed, tell the caller there is still a queue to pass off to. */
+       return false;
+}
+
+/*
+ * Hand the lock off to the first CPU on the queue.
+ */
+void tkt_q_do_wake(arch_spinlock_t *asp)
+{
+       struct tkt_q_head *tqhp;
+       struct tkt_q *tqp;
+
+       /* If the queue is still being set up, wait for it. */
+       while ((tqhp = tkt_q_find_head(asp)) == NULL)
+               cpu_relax();
+
+       for (;;) {
+
+               /* Find the first queue element. */
+               tqp = ACCESS_ONCE(tqhp->spin);
+               if (tqp != NULL)
+                       break;  /* Element exists, hand off lock. */
+               if (tkt_q_try_unqueue(asp, tqhp))
+                       return; /* No element, successfully removed queue. */
+               cpu_relax();
+       }
+       if (ACCESS_ONCE(tqhp->head_tkt) != -1)
+               ACCESS_ONCE(tqhp->head_tkt) = -1;
+       smp_mb(); /* Order pointer fetch and assignment against handoff. */
+       ACCESS_ONCE(tqp->cpu) = -1;
+}
+
+/*
+ * Given a lock that already has a queue associated with it, spin on
+ * that queue.  Return false if there was no queue (which means we do not
+ * hold the lock) and true otherwise (meaning we -do- hold the lock).
+ */
+bool tkt_q_do_spin(arch_spinlock_t *asp, struct __raw_tickets inc)
+{
+       struct tkt_q **oldtail;
+       struct tkt_q tq;
+       struct tkt_q_head *tqhp;
+
+       /*
+        * Ensure that accesses to queue header happen after sensing
+        * the lock's have-queue bit.
+        */
+       smp_mb();  /* See above block comment. */
+
+       /* If there no longer is a queue, leave. */
+       tqhp = tkt_q_find_head(asp);
+       if (tqhp == NULL)
+               return false;
+
+       /* Initialize our queue element. */
+       tq.cpu = raw_smp_processor_id();
+       tq.tail = inc.tail;
+       tq.next = NULL;
+
+       /* Check to see if we already hold the lock. */
+       if (ACCESS_ONCE(tqhp->head_tkt) == inc.tail) {
+               /* The last holder left before queue formed, we hold lock. */
+               tqhp->head_tkt = -1;
+               return true;
+       }
+
+       /* Add our element to the tail of the queue. */
+       oldtail = xchg(&tqhp->spin_tail, &tq.next);
+       ACCESS_ONCE(*oldtail) = &tq;
+
+       /* Spin until handoff. */
+       while (ACCESS_ONCE(tq.cpu) != -1)
+               cpu_relax();
+
+       /*
+        * Remove our element from the queue.  If the queue is now empty,
+        * update carefully so that the next acquisition will queue itself
+        * at the head of the list.
+        */
+       if (tq.next == NULL) {
+
+               /* Mark the queue empty. */
+               tqhp->spin = NULL;
+
+               /* Try to point the tail back at the head. */
+               if (cmpxchg(&tqhp->spin_tail,
+                           &tq.next,
+                           &tqhp->spin) == &tq.next)
+                       return true; /* Succeeded, queue is now empty. */
+
+               /* Failed, if needed, wait for the enqueue to complete. */
+               while (tq.next == NULL)
+                       cpu_relax();
+
+               /* The following code will repair the head. */
+       }
+       smp_mb(); /* Force ordering between handoff and critical section. */
+
+       /* Advance list-head pointer. */
+       ACCESS_ONCE(tqhp->spin) = tq.next;
+       return true;
+}
+
+/*
+ * Given a lock that does not have a queue, attempt to associate the
+ * i-th queue with it, returning true if successful (meaning we hold
+ * the lock) or false otherwise (meaning we do -not- hold the lock).
+ * Note that the caller has already filled in ->ref with 0x1, so we
+ * own the queue.
+ */
+static bool
+tkt_q_init_contend(int i, arch_spinlock_t *asp, struct __raw_tickets inc)
+{
+       arch_spinlock_t asold;
+       arch_spinlock_t asnew;
+       struct tkt_q_head *tqhp;
+
+       /* Initialize the i-th queue header. */
+       tqhp = &tkt_q_heads[i];
+       tqhp->spin = NULL;
+       tqhp->spin_tail = &tqhp->spin;
+
+       /* Each pass through this loop attempts to mark the lock as queued. */
+       do {
+               asold.head_tail = ACCESS_ONCE(asp->head_tail);
+               asnew = asold;
+               if (asnew.tickets.head & 0x1) {
+
+                       /* Someone beat us to it, back out. */
+                       smp_mb();
+                       ACCESS_ONCE(tqhp->ref) = NULL;
+
+                       /* Spin on the queue element they set up. */
+                       return tkt_q_do_spin(asp, inc);
+               }
+
+               /* The low-order bit in the head counter says "queued". */
+               asnew.tickets.head |= 0x1;
+       } while (cmpxchg(&asp->head_tail,
+                asold.head_tail,
+                asnew.head_tail) != asold.head_tail);
+

kernel/tktqlock.c line 265

Quoted 6 lines

kernel/tktqlock.c new file +6 -0

+       /* Point the queue at the lock and go spin on it. */
+       tqhp->head_tkt = asold.tickets.head;
+       smp_mb(); /* Ensure head_tkt is set prior to queuers seeing tqhp. */
+       ACCESS_ONCE(tqhp->ref) = asp;
+       return tkt_q_do_spin(asp, inc);
+}

Just small revise.

I just move " tqhp->head_tkt = asold.tickets.head;" into the loop, so we can use "asp->tickets.head & 0x1" to
indicates that queued spinlock is prepared instead of by "tqhp->ref == asp".

See the append diff.
(And I guess, after it you can force only the CPUs which "inc.tail - tqhp->head_tkt > TKT_Q_SWITCH"
do queued spin to remove the thundering herd)

kernel/tktqlock.c +6 -21

index f01b760..4ea409b 100644
@@ -27,7 +27,6 @@
 
 struct tkt_q {
        int cpu;
-       __ticket_t tail;
        struct tkt_q *next;
 };
 

@@ -127,9 +126,8 @@ void tkt_q_do_wake(arch_spinlock_t *asp)
        struct tkt_q_head *tqhp;
        struct tkt_q *tqp;
 
-       /* If the queue is still being set up, wait for it. */
-       while ((tqhp = tkt_q_find_head(asp)) == NULL)
-               cpu_relax();
+       tqhp = tkt_q_find_head(asp);
+       BUG_ON(!tqhp);
 
        for (;;) {
 

@@ -141,8 +139,6 @@ void tkt_q_do_wake(arch_spinlock_t *asp)
                        return; /* No element, successfully removed queue. */
                cpu_relax();
        }
-       if (ACCESS_ONCE(tqhp->head_tkt) != -1)
-               ACCESS_ONCE(tqhp->head_tkt) = -1;
        smp_mb(); /* Order pointer fetch and assignment against handoff. */
        ACCESS_ONCE(tqp->cpu) = -1;
 }

@@ -164,20 +160,16 @@ bool tkt_q_do_spin(arch_spinlock_t *asp, struct
 __raw_tickets inc)
         */
        smp_mb();  /* See above block comment. */
 
-       /* If there no longer is a queue, leave. */
        tqhp = tkt_q_find_head(asp);
-       if (tqhp == NULL)
-               return false;
+       BUG_ON(!tqhp);
 
        /* Initialize our queue element. */
        tq.cpu = raw_smp_processor_id();
-       tq.tail = inc.tail;
        tq.next = NULL;
 
        /* Check to see if we already hold the lock. */
        if (ACCESS_ONCE(tqhp->head_tkt) == inc.tail) {
                /* The last holder left before queue formed, we hold lock. */
-               tqhp->head_tkt = -1;
                return true;
        }

@@ -251,16 +243,14 @@ tkt_q_init_contend(int i, arch_spinlock_t *asp,
 struct __raw_tickets inc)
                        return tkt_q_do_spin(asp, inc);
                }
 
+               /* Point the queue at the lock and go spin on it. */
+               tqhp->head_tkt = asold.tickets.head;
                /* The low-order bit in the head counter says "queued". */
                asnew.tickets.head |= 0x1;
        } while (cmpxchg(&asp->head_tail,
                 asold.head_tail,
                 asnew.head_tail) != asold.head_tail);
 
-       /* Point the queue at the lock and go spin on it. */
-       tqhp->head_tkt = asold.tickets.head;
-       smp_mb(); /* Ensure head_tkt is set prior to queuers seeing tqhp. */
-       ACCESS_ONCE(tqhp->ref) = asp;
        return tkt_q_do_spin(asp, inc);
 }

@@ -282,14 +272,9 @@ bool tkt_q_start_contend(arch_spinlock_t *asp,
 struct __raw_tickets inc)
         * the lock with the corresponding queue.
         */
        do {
-               /*
-                * Use 0x1 to mark the queue in use, but also avoiding
-                * any spinners trying to use it before we get it all
-                * initialized.
-                */
                if (cmpxchg(&tkt_q_heads[i].ref,
                            NULL,
-                           (arch_spinlock_t *)0x1) == NULL) {
+                           asp) == NULL) {
 
                        /* Succeeded, now go initialize it. */