/* plock - progressive locks
 *
 * Copyright (C) 2012-2017 Willy Tarreau <w@1wt.eu>
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */

#ifndef PL_PLOCK_H
#define PL_PLOCK_H

#include "atomic-ops.h"
#ifdef _POSIX_PRIORITY_SCHEDULING
#include <sched.h>
#endif

/* 64 bit */
#define PLOCK64_RL_1   0x0000000000000004ULL
#define PLOCK64_RL_2PL 0x00000000FFFFFFF8ULL
#define PLOCK64_RL_ANY 0x00000000FFFFFFFCULL
#define PLOCK64_SL_1   0x0000000100000000ULL
#define PLOCK64_SL_ANY 0x0000000300000000ULL
#define PLOCK64_WL_1   0x0000000400000000ULL
#define PLOCK64_WL_2PL 0xFFFFFFF800000000ULL
#define PLOCK64_WL_ANY 0xFFFFFFFC00000000ULL

/* 32 bit */
#define PLOCK32_RL_1   0x00000004
#define PLOCK32_RL_2PL 0x0000FFF8
#define PLOCK32_RL_ANY 0x0000FFFC
#define PLOCK32_SL_1   0x00010000
#define PLOCK32_SL_ANY 0x00030000
#define PLOCK32_WL_1   0x00040000
#define PLOCK32_WL_2PL 0xFFF80000
#define PLOCK32_WL_ANY 0xFFFC0000

/* dereferences <*p> as unsigned long without causing aliasing issues */
#define pl_deref_long(p) ({ volatile unsigned long *__pl_l = (unsigned long *)(p); *__pl_l; })

/* dereferences <*p> as unsigned int without causing aliasing issues */
#define pl_deref_int(p) ({ volatile unsigned int *__pl_i = (unsigned int *)(p); *__pl_i; })

/* This function waits for <lock> to release all bits covered by <mask>, and
 * enforces an exponential backoff using CPU pauses to limit the pollution to
 * the other threads' caches. The progression follows (1.5^N)-1, limited to
 * 16384 iterations, which is way sufficient even for very large numbers of
 * threads. It's possible to disable exponential backoff (EBO) for debugging
 * purposes by setting PLOCK_DISABLE_EBO, in which case the function will be
 * replaced with a simpler macro. This may for example be useful to more
 * easily track callers' CPU usage. The macro was not designed to be used
 * outside of the functions defined here.
 */
#if defined(PLOCK_DISABLE_EBO)
#define pl_wait_unlock_long(lock, mask)           \
	({                                        \
		unsigned long _r;                 \
		do {                              \
			pl_cpu_relax();           \
			_r = pl_deref_long(lock); \
		} while (_r & mask);              \
		_r; /* return value */            \
	})
#else
__attribute__((unused,noinline,no_instrument_function))
static unsigned long pl_wait_unlock_long(const unsigned long *lock, const unsigned long mask)
{
	unsigned long ret;
	unsigned int m = 0;

	do {
		unsigned int loops = m;

#ifdef _POSIX_PRIORITY_SCHEDULING
		if (loops >= 65536) {
			sched_yield();
			loops -= 32768;
		}
#endif
		for (; loops >= 200; loops -= 10)
			pl_cpu_relax();

		for (; loops >= 1; loops--)
			pl_barrier();

		ret = pl_deref_long(lock);
		if (__builtin_expect(ret & mask, 0) == 0)
			break;

		/* the below produces an exponential growth with loops to lower
		 * values and still growing. This allows competing threads to
		 * wait different times once the threshold is reached.
		 */
		m = ((m + (m >> 1)) + 2) & 0x3ffff;
	} while (1);

	return ret;
}
#endif /* PLOCK_DISABLE_EBO */

/* This function waits for <lock> to release all bits covered by <mask>, and
 * enforces an exponential backoff using CPU pauses to limit the pollution to
 * the other threads' caches. The progression follows (2^N)-1, limited to 255
 * iterations, which is way sufficient even for very large numbers of threads.
 * The function slightly benefits from size optimization under gcc, but Clang
 * cannot do it, so it's not done here, as it doesn't make a big difference.
 * It is possible to disable exponential backoff (EBO) for debugging purposes
 * by setting PLOCK_DISABLE_EBO, in which case the function will be replaced
 * with a simpler macro. This may for example be useful to more easily track
 * callers' CPU usage. The macro was not designed to be used outside of the
 * functions defined here.
 */
#if defined(PLOCK_DISABLE_EBO)
#define pl_wait_unlock_int(lock, mask)            \
	({                                        \
		unsigned int _r;                  \
		do {                              \
			pl_cpu_relax();           \
			_r = pl_deref_int(lock);  \
		} while (_r & mask);              \
		_r; /* return value */            \
	})
#else
# if defined(PLOCK_INLINE_EBO)
__attribute__((unused,always_inline,no_instrument_function)) inline
# else
__attribute__((unused,noinline,no_instrument_function))
# endif
static unsigned int pl_wait_unlock_int(const unsigned int *lock, const unsigned int mask)
{
	unsigned int ret;
	unsigned int m = 0;

	do {
		unsigned int loops = m;

#ifdef _POSIX_PRIORITY_SCHEDULING
		if (loops >= 65536) {
			sched_yield();
			loops -= 32768;
		}
#endif
		for (; loops >= 200; loops -= 10)
			pl_cpu_relax();

		for (; loops >= 1; loops--)
			pl_barrier();

		ret = pl_deref_int(lock);
		if (__builtin_expect(ret & mask, 0) == 0)
			break;

		/* the below produces an exponential growth with loops to lower
		 * values and still growing. This allows competing threads to
		 * wait different times once the threshold is reached.
		 */
		m = ((m + (m >> 1)) + 2) & 0x3ffff;
	} while (1);

	return ret;
}
#endif /* PLOCK_DISABLE_EBO */

/* This function waits for <lock> to change from value <prev> and returns the
 * new value. It enforces an exponential backoff using CPU pauses to limit the
 * pollution to the other threads' caches. The progression follows (2^N)-1,
 * limited to 255 iterations, which is way sufficient even for very large
 * numbers of threads. It is designed to be called after a first test which
 * retrieves the previous value, so it starts by waiting. The function slightly
 * benefits from size optimization under gcc, but Clang cannot do it, so it's
 * not done here, as it doesn't make a big difference.
 */
__attribute__((unused,noinline,no_instrument_function))
static unsigned long pl_wait_new_long(const unsigned long *lock, const unsigned long prev)
{
	unsigned char m = 0;
	unsigned long curr;

	do {
		unsigned char loops = m + 1;
		m = (m << 1) + 1;
		do {
			pl_cpu_relax();
		} while (__builtin_expect(--loops, 0));
		curr = pl_deref_long(lock);
	} while (__builtin_expect(curr == prev, 0));
	return curr;
}

/* This function waits for <lock> to change from value <prev> and returns the
 * new value. It enforces an exponential backoff using CPU pauses to limit the
 * pollution to the other threads' caches. The progression follows (2^N)-1,
 * limited to 255 iterations, which is way sufficient even for very large
 * numbers of threads. It is designed to be called after a first test which
 * retrieves the previous value, so it starts by waiting. The function slightly
 * benefits from size optimization under gcc, but Clang cannot do it, so it's
 * not done here, as it doesn't make a big difference.
 */
__attribute__((unused,noinline,no_instrument_function))
static unsigned int pl_wait_new_int(const unsigned int *lock, const unsigned int prev)
{
	unsigned char m = 0;
	unsigned int curr;

	do {
		unsigned char loops = m + 1;
		m = (m << 1) + 1;
		do {
			pl_cpu_relax();
		} while (__builtin_expect(--loops, 0));
		curr = pl_deref_int(lock);
	} while (__builtin_expect(curr == prev, 0));
	return curr;
}

/* request shared read access (R), return non-zero on success, otherwise 0 */
#define pl_try_r(lock) (                                                                       \
	(sizeof(long) == 8 && sizeof(*(lock)) == 8) ? ({                                       \
		register unsigned long __pl_r = pl_deref_long(lock) & PLOCK64_WL_ANY;          \
		pl_barrier();                                                                  \
		if (!__builtin_expect(__pl_r, 0)) {                                            \
			__pl_r = pl_xadd((lock), PLOCK64_RL_1) & PLOCK64_WL_ANY;               \
			if (__builtin_expect(__pl_r, 0))                                       \
				pl_sub((lock), PLOCK64_RL_1);                                  \
		}                                                                              \
		!__pl_r; /* return value */                                                    \
	}) : (sizeof(*(lock)) == 4) ? ({                                                       \
		register unsigned int __pl_r = pl_deref_int(lock) & PLOCK32_WL_ANY;            \
		pl_barrier();                                                                  \
		if (!__builtin_expect(__pl_r, 0)) {                                            \
			__pl_r = pl_xadd((lock), PLOCK32_RL_1) & PLOCK32_WL_ANY;               \
			if (__builtin_expect(__pl_r, 0))                                       \
				pl_sub((lock), PLOCK32_RL_1);                                  \
		}                                                                              \
		!__pl_r; /* return value */                                                    \
	}) : ({                                                                                \
		void __unsupported_argument_size_for_pl_try_r__(char *,int);                   \
		if (sizeof(*(lock)) != 4 && (sizeof(long) != 8 || sizeof(*(lock)) != 8))       \
			__unsupported_argument_size_for_pl_try_r__(__FILE__,__LINE__);         \
		0;                                                                             \
	})                                                                                     \
)

/* request shared read access (R) and wait for it. In order not to disturb a W
 * lock waiting for all readers to leave, we first check if a W lock is held
 * before trying to claim the R lock.
 */
#define pl_take_r(lock)                                                                        \
	(sizeof(long) == 8 && sizeof(*(lock)) == 8) ? ({                                       \
		register unsigned long *__lk_r = (unsigned long *)(lock);                      \
		register unsigned long __set_r = PLOCK64_RL_1;                                 \
		register unsigned long __msk_r = PLOCK64_WL_ANY;                               \
		while (1) {                                                                    \
			if (__builtin_expect(pl_deref_long(__lk_r) & __msk_r, 0))              \
				pl_wait_unlock_long(__lk_r, __msk_r);                          \
			if (!__builtin_expect(pl_xadd(__lk_r, __set_r) & __msk_r, 0))          \
				break;                                                         \
			pl_sub(__lk_r, __set_r);                                               \
		}                                                                              \
		pl_barrier();                                                                  \
		0;                                                                             \
	}) : (sizeof(*(lock)) == 4) ? ({                                                       \
		register unsigned int *__lk_r = (unsigned int *)(lock);                        \
		register unsigned int __set_r = PLOCK32_RL_1;                                  \
		register unsigned int __msk_r = PLOCK32_WL_ANY;                                \
		while (1) {                                                                    \
			if (__builtin_expect(pl_deref_int(__lk_r) & __msk_r, 0))               \
				pl_wait_unlock_int(__lk_r, __msk_r);                           \
			if (!__builtin_expect(pl_xadd(__lk_r, __set_r) & __msk_r, 0))          \
				break;                                                         \
			pl_sub(__lk_r, __set_r);                                               \
		}                                                                              \
		pl_barrier();                                                                  \
		0;                                                                             \
	}) : ({                                                                                \
		void __unsupported_argument_size_for_pl_take_r__(char *,int);                  \
		if (sizeof(*(lock)) != 4 && (sizeof(long) != 8 || sizeof(*(lock)) != 8))       \
			__unsupported_argument_size_for_pl_take_r__(__FILE__,__LINE__);        \
		0;                                                                             \
	})

/* release the read access (R) lock */
#define pl_drop_r(lock) (                                                                      \
	(sizeof(long) == 8 && sizeof(*(lock)) == 8) ? ({                                       \
		pl_barrier();                                                                  \
		pl_sub(lock, PLOCK64_RL_1);                                                    \
	}) : (sizeof(*(lock)) == 4) ? ({                                                       \
		pl_barrier();                                                                  \
		pl_sub(lock, PLOCK32_RL_1);                                                    \
	}) : ({                                                                                \
		void __unsupported_argument_size_for_pl_drop_r__(char *,int);                  \
		if (sizeof(*(lock)) != 4 && (sizeof(long) != 8 || sizeof(*(lock)) != 8))       \
			__unsupported_argument_size_for_pl_drop_r__(__FILE__,__LINE__);        \
	})                                                                                     \
)

/* request a seek access (S), return non-zero on success, otherwise 0 */
#define pl_try_s(lock) (                                                                       \
	(sizeof(long) == 8 && sizeof(*(lock)) == 8) ? ({                                       \
		register unsigned long __pl_r = pl_deref_long(lock);                           \
		pl_barrier();                                                                  \
		if (!__builtin_expect(__pl_r & (PLOCK64_WL_ANY | PLOCK64_SL_ANY), 0)) {        \
			__pl_r = pl_xadd((lock), PLOCK64_SL_1 | PLOCK64_RL_1) &                \
			      (PLOCK64_WL_ANY | PLOCK64_SL_ANY);                               \
			if (__builtin_expect(__pl_r, 0))                                       \
				pl_sub((lock), PLOCK64_SL_1 | PLOCK64_RL_1);                   \
		}                                                                              \
		!__pl_r; /* return value */                                                    \
	}) : (sizeof(*(lock)) == 4) ? ({                                                       \
		register unsigned int __pl_r = pl_deref_int(lock);                             \
		pl_barrier();                                                                  \
		if (!__builtin_expect(__pl_r & (PLOCK32_WL_ANY | PLOCK32_SL_ANY), 0)) {        \
			__pl_r = pl_xadd((lock), PLOCK32_SL_1 | PLOCK32_RL_1) &                \
			      (PLOCK32_WL_ANY | PLOCK32_SL_ANY);                               \
			if (__builtin_expect(__pl_r, 0))                                       \
				pl_sub((lock), PLOCK32_SL_1 | PLOCK32_RL_1);                   \
		}                                                                              \
		!__pl_r; /* return value */                                                    \
	}) : ({                                                                                \
		void __unsupported_argument_size_for_pl_try_s__(char *,int);                   \
		if (sizeof(*(lock)) != 4 && (sizeof(long) != 8 || sizeof(*(lock)) != 8))       \
			__unsupported_argument_size_for_pl_try_s__(__FILE__,__LINE__);         \
		0;                                                                             \
	})                                                                                     \
)

/* request a seek access (S) and wait for it. The lock is immediately claimed,
 * and only upon failure an exponential backoff is used. S locks rarely compete
 * with W locks so S will generally not disturb W. As the S lock may be used as
 * a spinlock, it's important to grab it as fast as possible.
 */
#define pl_take_s(lock)                                                                        \
	(sizeof(long) == 8 && sizeof(*(lock)) == 8) ? ({                                       \
		register unsigned long *__lk_r = (unsigned long *)(lock);                      \
		register unsigned long __set_r = PLOCK64_SL_1 | PLOCK64_RL_1;                  \
		register unsigned long __msk_r = PLOCK64_WL_ANY | PLOCK64_SL_ANY;              \
		while (1) {                                                                    \
			if (!__builtin_expect(pl_xadd(__lk_r, __set_r) & __msk_r, 0))          \
				break;                                                         \
			pl_sub(__lk_r, __set_r);                                               \
			pl_wait_unlock_long(__lk_r, __msk_r);                                  \
		}                                                                              \
		pl_barrier();                                                                  \
		0;                                                                             \
	}) : (sizeof(*(lock)) == 4) ? ({                                                       \
		register unsigned int *__lk_r = (unsigned int *)(lock);                        \
		register unsigned int __set_r = PLOCK32_SL_1 | PLOCK32_RL_1;                   \
		register unsigned int __msk_r = PLOCK32_WL_ANY | PLOCK32_SL_ANY;               \
		while (1) {                                                                    \
			if (!__builtin_expect(pl_xadd(__lk_r, __set_r) & __msk_r, 0))          \
				break;                                                         \
			pl_sub(__lk_r, __set_r);                                               \
			pl_wait_unlock_int(__lk_r, __msk_r);                                   \
		}                                                                              \
		pl_barrier();                                                                  \
		0;                                                                             \
	}) : ({                                                                                \
		void __unsupported_argument_size_for_pl_take_s__(char *,int);                  \
		if (sizeof(*(lock)) != 4 && (sizeof(long) != 8 || sizeof(*(lock)) != 8))       \
			__unsupported_argument_size_for_pl_take_s__(__FILE__,__LINE__);        \
		0;                                                                             \
	})

/* release the seek access (S) lock */
#define pl_drop_s(lock) (                                                                      \
	(sizeof(long) == 8 && sizeof(*(lock)) == 8) ? ({                                       \
		pl_barrier();                                                                  \
		pl_sub(lock, PLOCK64_SL_1 + PLOCK64_RL_1);                                     \
	}) : (sizeof(*(lock)) == 4) ? ({                                                       \
		pl_barrier();                                                                  \
		pl_sub(lock, PLOCK32_SL_1 + PLOCK32_RL_1);                                     \
	}) : ({                                                                                \
		void __unsupported_argument_size_for_pl_drop_s__(char *,int);                  \
		if (sizeof(*(lock)) != 4 && (sizeof(long) != 8 || sizeof(*(lock)) != 8))       \
			__unsupported_argument_size_for_pl_drop_s__(__FILE__,__LINE__);        \
	})                                                                                     \
)

/* drop the S lock and go back to the R lock */
#define pl_stor(lock) (                                                                        \
	(sizeof(long) == 8 && sizeof(*(lock)) == 8) ? ({                                       \
		pl_barrier();                                                                  \
		pl_sub(lock, PLOCK64_SL_1);                                                    \
	}) : (sizeof(*(lock)) == 4) ? ({                                                       \
		pl_barrier();                                                                  \
		pl_sub(lock, PLOCK32_SL_1);                                                    \
	}) : ({                                                                                \
		void __unsupported_argument_size_for_pl_stor__(char *,int);                    \
		if (sizeof(*(lock)) != 4 && (sizeof(long) != 8 || sizeof(*(lock)) != 8))       \
			__unsupported_argument_size_for_pl_stor__(__FILE__,__LINE__);          \
	})                                                                                     \
)

/* take the W lock under the S lock */
#define pl_stow(lock) (                                                                        \
	(sizeof(long) == 8 && sizeof(*(lock)) == 8) ? ({                                       \
		register unsigned long __pl_r = pl_xadd((lock), PLOCK64_WL_1);                 \
		while ((__pl_r & PLOCK64_RL_ANY) != PLOCK64_RL_1)                              \
			__pl_r = pl_deref_long(lock);                                          \
		pl_barrier();                                                                  \
	}) : (sizeof(*(lock)) == 4) ? ({                                                       \
		register unsigned int __pl_r = pl_xadd((lock), PLOCK32_WL_1);                  \
		while ((__pl_r & PLOCK32_RL_ANY) != PLOCK32_RL_1)                              \
			__pl_r = pl_deref_int(lock);                                           \
		pl_barrier();                                                                  \
	}) : ({                                                                                \
		void __unsupported_argument_size_for_pl_stow__(char *,int);                    \
		if (sizeof(*(lock)) != 4 && (sizeof(long) != 8 || sizeof(*(lock)) != 8))       \
			__unsupported_argument_size_for_pl_stow__(__FILE__,__LINE__);          \
	})                                                                                     \
)

/* drop the W lock and go back to the S lock */
#define pl_wtos(lock) (                                                                        \
	(sizeof(long) == 8 && sizeof(*(lock)) == 8) ? ({                                       \
		pl_barrier();                                                                  \
		pl_sub(lock, PLOCK64_WL_1);                                                    \
	}) : (sizeof(*(lock)) == 4) ? ({                                                       \
		pl_barrier();                                                                  \
		pl_sub(lock, PLOCK32_WL_1);                                                    \
	}) : ({                                                                                \
		void __unsupported_argument_size_for_pl_wtos__(char *,int);                    \
		if (sizeof(*(lock)) != 4 && (sizeof(long) != 8 || sizeof(*(lock)) != 8))       \
			__unsupported_argument_size_for_pl_wtos__(__FILE__,__LINE__);          \
	})                                                                                     \
)

/* drop the W lock and go back to the R lock */
#define pl_wtor(lock) (                                                                        \
	(sizeof(long) == 8 && sizeof(*(lock)) == 8) ? ({                                       \
		pl_barrier();                                                                  \
		pl_sub(lock, PLOCK64_WL_1 | PLOCK64_SL_1);                                     \
	}) : (sizeof(*(lock)) == 4) ? ({                                                       \
		pl_barrier();                                                                  \
		pl_sub(lock, PLOCK32_WL_1 | PLOCK32_SL_1);                                     \
	}) : ({                                                                                \
		void __unsupported_argument_size_for_pl_wtor__(char *,int);                    \
		if (sizeof(*(lock)) != 4 && (sizeof(long) != 8 || sizeof(*(lock)) != 8))       \
			__unsupported_argument_size_for_pl_wtor__(__FILE__,__LINE__);          \
	})                                                                                     \
)

/* request a write access (W), return non-zero on success, otherwise 0.
 *
 * Below there is something important : by taking both W and S, we will cause
 * an overflow of W at 4/5 of the maximum value that can be stored into W due
 * to the fact that S is 2 bits, so we're effectively adding 5 to the word
 * composed by W:S. But for all words multiple of 4 bits, the maximum value is
 * multiple of 15 thus of 5. So the largest value we can store with all bits
 * set to one will be met by adding 5, and then adding 5 again will place value
 * 1 in W and value 0 in S, so we never leave W with 0. Also, even upon such an
 * overflow, there's no risk to confuse it with an atomic lock because R is not
 * null since it will not have overflown. For 32-bit locks, this situation
 * happens when exactly 13108 threads try to grab the lock at once, W=1, S=0
 * and R=13108. For 64-bit locks, it happens at 858993460 concurrent writers
 * where W=1, S=0 and R=858993460.
 */
#define pl_try_w(lock) (                                                                       \
	(sizeof(long) == 8 && sizeof(*(lock)) == 8) ? ({                                       \
		register unsigned long __pl_r = pl_deref_long(lock);                           \
		pl_barrier();                                                                  \
		if (!__builtin_expect(__pl_r & (PLOCK64_WL_ANY | PLOCK64_SL_ANY), 0)) {        \
			__pl_r = pl_xadd((lock), PLOCK64_WL_1 | PLOCK64_SL_1 | PLOCK64_RL_1);  \
			if (__builtin_expect(__pl_r & (PLOCK64_WL_ANY | PLOCK64_SL_ANY), 0)) { \
				/* a writer, seeker or atomic is present, let's leave */       \
				pl_sub((lock), PLOCK64_WL_1 | PLOCK64_SL_1 | PLOCK64_RL_1);    \
				__pl_r &= (PLOCK64_WL_ANY | PLOCK64_SL_ANY); /* return value */\
			} else {                                                               \
				/* wait for all other readers to leave */                      \
				while (__pl_r)                                                 \
					__pl_r = pl_deref_long(lock) -                         \
						(PLOCK64_WL_1 | PLOCK64_SL_1 | PLOCK64_RL_1);  \
			}                                                                      \
		}                                                                              \
		!__pl_r; /* return value */                                                    \
	}) : (sizeof(*(lock)) == 4) ? ({                                                       \
		register unsigned int __pl_r = pl_deref_int(lock);                             \
		pl_barrier();                                                                  \
		if (!__builtin_expect(__pl_r & (PLOCK32_WL_ANY | PLOCK32_SL_ANY), 0)) {        \
			__pl_r = pl_xadd((lock), PLOCK32_WL_1 | PLOCK32_SL_1 | PLOCK32_RL_1);  \
			if (__builtin_expect(__pl_r & (PLOCK32_WL_ANY | PLOCK32_SL_ANY), 0)) { \
				/* a writer, seeker or atomic is present, let's leave */       \
				pl_sub((lock), PLOCK32_WL_1 | PLOCK32_SL_1 | PLOCK32_RL_1);    \
				__pl_r &= (PLOCK32_WL_ANY | PLOCK32_SL_ANY); /* return value */\
			} else {                                                               \
				/* wait for all other readers to leave */                      \
				while (__pl_r)                                                 \
					__pl_r = pl_deref_int(lock) -                          \
						(PLOCK32_WL_1 | PLOCK32_SL_1 | PLOCK32_RL_1);  \
			}                                                                      \
		}                                                                              \
		!__pl_r; /* return value */                                                    \
	}) : ({                                                                                \
		void __unsupported_argument_size_for_pl_try_w__(char *,int);                   \
		if (sizeof(*(lock)) != 4 && (sizeof(long) != 8 || sizeof(*(lock)) != 8))       \
			__unsupported_argument_size_for_pl_try_w__(__FILE__,__LINE__);         \
		0;                                                                             \
	})                                                                                     \
)

/* request a write access (W) and wait for it. The lock is immediately claimed,
 * and only upon failure an exponential backoff is used.
 */
#define pl_take_w(lock)                                                                        \
	(sizeof(long) == 8 && sizeof(*(lock)) == 8) ? ({                                       \
		register unsigned long *__lk_r = (unsigned long *)(lock);                      \
		register unsigned long __set_r = PLOCK64_WL_1 | PLOCK64_SL_1 | PLOCK64_RL_1;   \
		register unsigned long __msk_r = PLOCK64_WL_ANY | PLOCK64_SL_ANY;              \
		register unsigned long __pl_r;                                                 \
		while (1) {                                                                    \
			__pl_r = pl_xadd(__lk_r, __set_r);                                     \
			if (!__builtin_expect(__pl_r & __msk_r, 0))                            \
				break;                                                         \
			pl_sub(__lk_r, __set_r);                                               \
			__pl_r = pl_wait_unlock_long(__lk_r, __msk_r);                         \
		}                                                                              \
		/* wait for all other readers to leave */                                      \
		while (__builtin_expect(__pl_r, 0))                                            \
			__pl_r = pl_deref_long(__lk_r) - __set_r;                              \
		pl_barrier();                                                                  \
		0;                                                                             \
	}) : (sizeof(*(lock)) == 4) ? ({                                                       \
		register unsigned int *__lk_r = (unsigned int *)(lock);                        \
		register unsigned int __set_r = PLOCK32_WL_1 | PLOCK32_SL_1 | PLOCK32_RL_1;    \
		register unsigned int __msk_r = PLOCK32_WL_ANY | PLOCK32_SL_ANY;               \
		register unsigned int __pl_r;                                                  \
		while (1) {                                                                    \
			__pl_r = pl_xadd(__lk_r, __set_r);                                     \
			if (!__builtin_expect(__pl_r & __msk_r, 0))                            \
				break;                                                         \
			pl_sub(__lk_r, __set_r);                                               \
			__pl_r = pl_wait_unlock_int(__lk_r, __msk_r);                          \
		}                                                                              \
		/* wait for all other readers to leave */                                      \
		while (__builtin_expect(__pl_r, 0))                                            \
			__pl_r = pl_deref_int(__lk_r) - __set_r;                               \
		pl_barrier();                                                                  \
		0;                                                                             \
	}) : ({                                                                                \
		void __unsupported_argument_size_for_pl_take_w__(char *,int);                  \
		if (sizeof(*(lock)) != 4 && (sizeof(long) != 8 || sizeof(*(lock)) != 8))       \
			__unsupported_argument_size_for_pl_take_w__(__FILE__,__LINE__);        \
		0;                                                                             \
	})

/* drop the write (W) lock entirely */
#define pl_drop_w(lock) (                                                                      \
	(sizeof(long) == 8 && sizeof(*(lock)) == 8) ? ({                                       \
		pl_barrier();                                                                  \
		pl_sub(lock, PLOCK64_WL_1 | PLOCK64_SL_1 | PLOCK64_RL_1);                      \
	}) : (sizeof(*(lock)) == 4) ? ({                                                       \
		pl_barrier();                                                                  \
		pl_sub(lock, PLOCK32_WL_1 | PLOCK32_SL_1 | PLOCK32_RL_1);                      \
	}) : ({                                                                                \
		void __unsupported_argument_size_for_pl_drop_w__(char *,int);                  \
		if (sizeof(*(lock)) != 4 && (sizeof(long) != 8 || sizeof(*(lock)) != 8))       \
			__unsupported_argument_size_for_pl_drop_w__(__FILE__,__LINE__);        \
	})                                                                                     \
)

/* Try to upgrade from R to S, return non-zero on success, otherwise 0.
 * This lock will fail if S or W are already held. In case of failure to grab
 * the lock, it MUST NOT be retried without first dropping R, or it may never
 * complete due to S waiting for R to leave before upgrading to W.
 */
#define pl_try_rtos(lock) (                                                                    \
	(sizeof(long) == 8 && sizeof(*(lock)) == 8) ? ({                                       \
		register unsigned long __pl_r = pl_deref_long(lock);                           \
		pl_barrier();                                                                  \
		if (!__builtin_expect(__pl_r & (PLOCK64_WL_ANY | PLOCK64_SL_ANY), 0)) {        \
			__pl_r = pl_xadd((lock), PLOCK64_SL_1) &                               \
			      (PLOCK64_WL_ANY | PLOCK64_SL_ANY);                               \
			if (__builtin_expect(__pl_r, 0))                                       \
				pl_sub((lock), PLOCK64_SL_1);                                  \
		}                                                                              \
		!__pl_r; /* return value */                                                    \
	}) : (sizeof(*(lock)) == 4) ? ({                                                       \
		register unsigned int __pl_r = pl_deref_int(lock);                             \
		pl_barrier();                                                                  \
		if (!__builtin_expect(__pl_r & (PLOCK32_WL_ANY | PLOCK32_SL_ANY), 0)) {        \
			__pl_r = pl_xadd((lock), PLOCK32_SL_1) &                               \
			      (PLOCK32_WL_ANY | PLOCK32_SL_ANY);                               \
			if (__builtin_expect(__pl_r, 0))                                       \
				pl_sub((lock), PLOCK32_SL_1);                                  \
		}                                                                              \
		!__pl_r; /* return value */                                                    \
	}) : ({                                                                                \
		void __unsupported_argument_size_for_pl_try_rtos__(char *,int);                \
		if (sizeof(*(lock)) != 4 && (sizeof(long) != 8 || sizeof(*(lock)) != 8))       \
			__unsupported_argument_size_for_pl_try_rtos__(__FILE__,__LINE__);      \
		0;                                                                             \
	})                                                                                     \
)


/* Try to upgrade from R to W, return non-zero on success, otherwise 0.
 * This lock will fail if S or W are already held. In case of failure to grab
 * the lock, it MUST NOT be retried without first dropping R, or it may never
 * complete due to S waiting for R to leave before upgrading to W. It waits for
 * the last readers to leave.
 */
#define pl_try_rtow(lock) (                                                                    \
	(sizeof(long) == 8 && sizeof(*(lock)) == 8) ? ({                                       \
		register unsigned long *__lk_r = (unsigned long *)(lock);                      \
		register unsigned long __set_r = PLOCK64_WL_1 | PLOCK64_SL_1;                  \
		register unsigned long __msk_r = PLOCK64_WL_ANY | PLOCK64_SL_ANY;              \
		register unsigned long __pl_r;                                                 \
		pl_barrier();                                                                  \
		while (1) {                                                                    \
			__pl_r = pl_xadd(__lk_r, __set_r);                                     \
			if (__builtin_expect(__pl_r & __msk_r, 0)) {                           \
				if (pl_xadd(__lk_r, - __set_r))                                \
					break; /* the caller needs to drop the lock now */     \
				continue;  /* lock was released, try again */                  \
			}                                                                      \
			/* ok we're the only writer, wait for readers to leave */              \
			while (__builtin_expect(__pl_r, 0))                                    \
				__pl_r = pl_deref_long(__lk_r) - (PLOCK64_WL_1|PLOCK64_SL_1|PLOCK64_RL_1); \
			/* now return with __pl_r = 0 */                                       \
			break;                                                                 \
		}                                                                              \
		!__pl_r; /* return value */                                                    \
	}) : (sizeof(*(lock)) == 4) ? ({                                                       \
		register unsigned int *__lk_r = (unsigned int *)(lock);                        \
		register unsigned int __set_r = PLOCK32_WL_1 | PLOCK32_SL_1;                   \
		register unsigned int __msk_r = PLOCK32_WL_ANY | PLOCK32_SL_ANY;               \
		register unsigned int __pl_r;                                                  \
		pl_barrier();                                                                  \
		while (1) {                                                                    \
			__pl_r = pl_xadd(__lk_r, __set_r);                                     \
			if (__builtin_expect(__pl_r & __msk_r, 0)) {                           \
				if (pl_xadd(__lk_r, - __set_r))                                \
					break; /* the caller needs to drop the lock now */     \
				continue;  /* lock was released, try again */                  \
			}                                                                      \
			/* ok we're the only writer, wait for readers to leave */              \
			while (__builtin_expect(__pl_r, 0))                                    \
				__pl_r = pl_deref_int(__lk_r) - (PLOCK32_WL_1|PLOCK32_SL_1|PLOCK32_RL_1); \
			/* now return with __pl_r = 0 */                                       \
			break;                                                                 \
		}                                                                              \
		!__pl_r; /* return value */                                                    \
	}) : ({                                                                                \
		void __unsupported_argument_size_for_pl_try_rtow__(char *,int);                \
		if (sizeof(*(lock)) != 4 && (sizeof(long) != 8 || sizeof(*(lock)) != 8))       \
			__unsupported_argument_size_for_pl_try_rtow__(__FILE__,__LINE__);      \
		0;                                                                             \
	})                                                                                     \
)


/* request atomic write access (A), return non-zero on success, otherwise 0.
 * It's a bit tricky as we only use the W bits for this and want to distinguish
 * between other atomic users and regular lock users. We have to give up if an
 * S lock appears. It's possible that such a lock stays hidden in the W bits
 * after an overflow, but in this case R is still held, ensuring we stay in the
 * loop until we discover the conflict. The lock only return successfully if all
 * readers are gone (or converted to A).
 */
#define pl_try_a(lock) (                                                                       \
	(sizeof(long) == 8 && sizeof(*(lock)) == 8) ? ({                                       \
		register unsigned long __pl_r = pl_deref_long(lock) & PLOCK64_SL_ANY;          \
		pl_barrier();                                                                  \
		if (!__builtin_expect(__pl_r, 0)) {                                            \
			__pl_r = pl_xadd((lock), PLOCK64_WL_1);                                \
			while (1) {                                                            \
				if (__builtin_expect(__pl_r & PLOCK64_SL_ANY, 0)) {            \
					pl_sub((lock), PLOCK64_WL_1);                          \
					break;  /* return !__pl_r */                           \
				}                                                              \
				__pl_r &= PLOCK64_RL_ANY;                                      \
				if (!__builtin_expect(__pl_r, 0))                              \
					break;  /* return !__pl_r */                           \
				__pl_r = pl_deref_long(lock);                                  \
			}                                                                      \
		}                                                                              \
		!__pl_r; /* return value */                                                    \
	}) : (sizeof(*(lock)) == 4) ? ({                                                       \
		register unsigned int __pl_r = pl_deref_int(lock) & PLOCK32_SL_ANY;            \
		pl_barrier();                                                                  \
		if (!__builtin_expect(__pl_r, 0)) {                                            \
			__pl_r = pl_xadd((lock), PLOCK32_WL_1);                                \
			while (1) {                                                            \
				if (__builtin_expect(__pl_r & PLOCK32_SL_ANY, 0)) {            \
					pl_sub((lock), PLOCK32_WL_1);                          \
					break;  /* return !__pl_r */                           \
				}                                                              \
				__pl_r &= PLOCK32_RL_ANY;                                      \
				if (!__builtin_expect(__pl_r, 0))                              \
					break;  /* return !__pl_r */                           \
				__pl_r = pl_deref_int(lock);                                   \
			}                                                                      \
		}                                                                              \
		!__pl_r; /* return value */                                                    \
	}) : ({                                                                                \
		void __unsupported_argument_size_for_pl_try_a__(char *,int);                   \
		if (sizeof(*(lock)) != 4 && (sizeof(long) != 8 || sizeof(*(lock)) != 8))       \
			__unsupported_argument_size_for_pl_try_a__(__FILE__,__LINE__);         \
		0;                                                                             \
	})                                                                                     \
)

/* request atomic write access (A) and wait for it. See comments in pl_try_a() for
 * explanations.
 */
#define pl_take_a(lock)                                                                        \
	(sizeof(long) == 8 && sizeof(*(lock)) == 8) ? ({                                       \
		register unsigned long *__lk_r = (unsigned long *)(lock);                      \
		register unsigned long __set_r = PLOCK64_WL_1;                                 \
		register unsigned long __msk_r = PLOCK64_SL_ANY;                               \
		register unsigned long __pl_r;                                                 \
		__pl_r = pl_xadd(__lk_r, __set_r);                                             \
		while (__builtin_expect(__pl_r & PLOCK64_RL_ANY, 0)) {                         \
			if (__builtin_expect(__pl_r & __msk_r, 0)) {                           \
				pl_sub(__lk_r, __set_r);                                       \
				pl_wait_unlock_long(__lk_r, __msk_r);                          \
				__pl_r = pl_xadd(__lk_r, __set_r);                             \
				continue;                                                      \
			}                                                                      \
			/* wait for all readers to leave or upgrade */                         \
			pl_cpu_relax(); pl_cpu_relax(); pl_cpu_relax();                        \
			__pl_r = pl_deref_long(lock);                                          \
		}                                                                              \
		pl_barrier();                                                                  \
		0;                                                                             \
	}) : (sizeof(*(lock)) == 4) ? ({                                                       \
		register unsigned int *__lk_r = (unsigned int *)(lock);                        \
		register unsigned int __set_r = PLOCK32_WL_1;                                  \
		register unsigned int __msk_r = PLOCK32_SL_ANY;                                \
		register unsigned int __pl_r;                                                  \
		__pl_r = pl_xadd(__lk_r, __set_r);                                             \
		while (__builtin_expect(__pl_r & PLOCK32_RL_ANY, 0)) {                         \
			if (__builtin_expect(__pl_r & __msk_r, 0)) {                           \
				pl_sub(__lk_r, __set_r);                                       \
				pl_wait_unlock_int(__lk_r, __msk_r);                           \
				__pl_r = pl_xadd(__lk_r, __set_r);                             \
				continue;                                                      \
			}                                                                      \
			/* wait for all readers to leave or upgrade */                         \
			pl_cpu_relax(); pl_cpu_relax(); pl_cpu_relax();                        \
			__pl_r = pl_deref_int(lock);                                           \
		}                                                                              \
		pl_barrier();                                                                  \
		0;                                                                             \
	}) : ({                                                                                \
		void __unsupported_argument_size_for_pl_take_a__(char *,int);                  \
		if (sizeof(*(lock)) != 4 && (sizeof(long) != 8 || sizeof(*(lock)) != 8))       \
			__unsupported_argument_size_for_pl_take_a__(__FILE__,__LINE__);        \
		0;                                                                             \
	})

/* release atomic write access (A) lock */
#define pl_drop_a(lock) (                                                                      \
	(sizeof(long) == 8 && sizeof(*(lock)) == 8) ? ({                                       \
		pl_barrier();                                                                  \
		pl_sub(lock, PLOCK64_WL_1);                                                    \
	}) : (sizeof(*(lock)) == 4) ? ({                                                       \
		pl_barrier();                                                                  \
		pl_sub(lock, PLOCK32_WL_1);                                                    \
	}) : ({                                                                                \
		void __unsupported_argument_size_for_pl_drop_a__(char *,int);                  \
		if (sizeof(*(lock)) != 4 && (sizeof(long) != 8 || sizeof(*(lock)) != 8))       \
			__unsupported_argument_size_for_pl_drop_a__(__FILE__,__LINE__);        \
	})                                                                                     \
)

/* Downgrade A to R. Inc(R), dec(W) then wait for W==0 */
#define pl_ator(lock) (                                                                        \
	(sizeof(long) == 8 && sizeof(*(lock)) == 8) ? ({                                       \
		register unsigned long *__lk_r = (unsigned long *)(lock);                      \
		register unsigned long __set_r = PLOCK64_RL_1 - PLOCK64_WL_1;                  \
		register unsigned long __msk_r = PLOCK64_WL_ANY;                               \
		register unsigned long __pl_r = pl_xadd(__lk_r, __set_r) + __set_r;            \
		while (__builtin_expect(__pl_r & __msk_r, 0)) {                                \
			__pl_r = pl_wait_unlock_long(__lk_r, __msk_r);                         \
		}                                                                              \
		pl_barrier();                                                                  \
	}) : (sizeof(*(lock)) == 4) ? ({                                                       \
		register unsigned int *__lk_r = (unsigned int *)(lock);                        \
		register unsigned int __set_r = PLOCK32_RL_1 - PLOCK32_WL_1;                   \
		register unsigned int __msk_r = PLOCK32_WL_ANY;                                \
		register unsigned int __pl_r = pl_xadd(__lk_r, __set_r) + __set_r;             \
		while (__builtin_expect(__pl_r & __msk_r, 0)) {                                \
			__pl_r = pl_wait_unlock_int(__lk_r, __msk_r);                          \
		}                                                                              \
		pl_barrier();                                                                  \
	}) : ({                                                                                \
		void __unsupported_argument_size_for_pl_ator__(char *,int);                    \
		if (sizeof(*(lock)) != 4 && (sizeof(long) != 8 || sizeof(*(lock)) != 8))       \
			__unsupported_argument_size_for_pl_ator__(__FILE__,__LINE__);          \
	})                                                                                     \
)

/* Try to upgrade from R to A, return non-zero on success, otherwise 0.
 * This lock will fail if S is held or appears while waiting (typically due to
 * a previous grab that was disguised as a W due to an overflow). In case of
 * failure to grab the lock, it MUST NOT be retried without first dropping R,
 * or it may never complete due to S waiting for R to leave before upgrading
 * to W. The lock succeeds once there's no more R (ie all of them have either
 * completed or were turned to A).
 */
#define pl_try_rtoa(lock) (                                                                    \
	(sizeof(long) == 8 && sizeof(*(lock)) == 8) ? ({                                       \
		register unsigned long __pl_r = pl_deref_long(lock) & PLOCK64_SL_ANY;          \
		pl_barrier();                                                                  \
		if (!__builtin_expect(__pl_r, 0)) {                                            \
			__pl_r = pl_xadd((lock), PLOCK64_WL_1 - PLOCK64_RL_1);                 \
			while (1) {                                                            \
				if (__builtin_expect(__pl_r & PLOCK64_SL_ANY, 0)) {            \
					pl_sub((lock), PLOCK64_WL_1 - PLOCK64_RL_1);           \
					break;  /* return !__pl_r */                           \
				}                                                              \
				__pl_r &= PLOCK64_RL_ANY;                                      \
				if (!__builtin_expect(__pl_r, 0))                              \
					break;  /* return !__pl_r */                           \
				__pl_r = pl_deref_long(lock);                                  \
			}                                                                      \
		}                                                                              \
		!__pl_r; /* return value */                                                    \
	}) : (sizeof(*(lock)) == 4) ? ({                                                       \
		register unsigned int __pl_r = pl_deref_int(lock) & PLOCK32_SL_ANY;            \
		pl_barrier();                                                                  \
		if (!__builtin_expect(__pl_r, 0)) {                                            \
			__pl_r = pl_xadd((lock), PLOCK32_WL_1 - PLOCK32_RL_1);                 \
			while (1) {                                                            \
				if (__builtin_expect(__pl_r & PLOCK32_SL_ANY, 0)) {            \
					pl_sub((lock), PLOCK32_WL_1 - PLOCK32_RL_1);           \
					break;  /* return !__pl_r */                           \
				}                                                              \
				__pl_r &= PLOCK32_RL_ANY;                                      \
				if (!__builtin_expect(__pl_r, 0))                              \
					break;  /* return !__pl_r */                           \
				__pl_r = pl_deref_int(lock);                                   \
			}                                                                      \
		}                                                                              \
		!__pl_r; /* return value */                                                    \
	}) : ({                                                                                \
		void __unsupported_argument_size_for_pl_try_rtoa__(char *,int);                \
		if (sizeof(*(lock)) != 4 && (sizeof(long) != 8 || sizeof(*(lock)) != 8))       \
			__unsupported_argument_size_for_pl_try_rtoa__(__FILE__,__LINE__);      \
		0;                                                                             \
	})                                                                                     \
)


/*
 * The following operations cover the multiple writers model : U->R->J->C->A
 */


/* Upgrade R to J. Inc(W) then wait for R==W or S != 0 */
#define pl_rtoj(lock) (                                                                        \
	(sizeof(long) == 8 && sizeof(*(lock)) == 8) ? ({                                       \
		register unsigned long *__lk_r = (unsigned long *)(lock);                      \
		register unsigned long __pl_r = pl_xadd(__lk_r, PLOCK64_WL_1) + PLOCK64_WL_1;  \
		register unsigned char __m = 0;                                                \
		while (!(__pl_r & PLOCK64_SL_ANY) &&                                           \
		       (__pl_r / PLOCK64_WL_1 != (__pl_r & PLOCK64_RL_ANY) / PLOCK64_RL_1)) {  \
			unsigned char __loops = __m + 1;                                       \
			__m = (__m << 1) + 1;                                                  \
			do {                                                                   \
				pl_cpu_relax();                                                \
				pl_cpu_relax();                                                \
			} while (--__loops);                                                   \
			__pl_r = pl_deref_long(__lk_r);                                        \
		}                                                                              \
		pl_barrier();                                                                  \
	}) : (sizeof(*(lock)) == 4) ? ({                                                       \
		register unsigned int *__lk_r = (unsigned int *)(lock);                        \
		register unsigned int __pl_r = pl_xadd(__lk_r, PLOCK32_WL_1) + PLOCK32_WL_1;   \
		register unsigned char __m = 0;                                                \
		while (!(__pl_r & PLOCK32_SL_ANY) &&                                           \
		       (__pl_r / PLOCK32_WL_1 != (__pl_r & PLOCK32_RL_ANY) / PLOCK32_RL_1)) {  \
			unsigned char __loops = __m + 1;                                       \
			__m = (__m << 1) + 1;                                                  \
			do {                                                                   \
				pl_cpu_relax();                                                \
				pl_cpu_relax();                                                \
			} while (--__loops);                                                   \
			__pl_r = pl_deref_int(__lk_r);                                         \
		}                                                                              \
		pl_barrier();                                                                  \
	}) : ({                                                                                \
		void __unsupported_argument_size_for_pl_rtoj__(char *,int);                    \
		if (sizeof(*(lock)) != 4 && (sizeof(long) != 8 || sizeof(*(lock)) != 8))       \
			__unsupported_argument_size_for_pl_rtoj__(__FILE__,__LINE__);          \
	})                                                                                     \
)

/* Upgrade J to C. Set S. Only one thread needs to do it though it's idempotent */
#define pl_jtoc(lock) (                                                                        \
	(sizeof(long) == 8 && sizeof(*(lock)) == 8) ? ({                                       \
		register unsigned long *__lk_r = (unsigned long *)(lock);                      \
		register unsigned long __pl_r = pl_deref_long(__lk_r);                         \
		if (!(__pl_r & PLOCK64_SL_ANY))                                                \
			pl_or(__lk_r, PLOCK64_SL_1);                                           \
		pl_barrier();                                                                  \
	}) : (sizeof(*(lock)) == 4) ? ({                                                       \
		register unsigned int *__lk_r = (unsigned int *)(lock);                        \
		register unsigned int __pl_r = pl_deref_int(__lk_r);                           \
		if (!(__pl_r & PLOCK32_SL_ANY))                                                \
			pl_or(__lk_r, PLOCK32_SL_1);                                           \
		pl_barrier();                                                                  \
	}) : ({                                                                                \
		void __unsupported_argument_size_for_pl_jtoc__(char *,int);                    \
		if (sizeof(*(lock)) != 4 && (sizeof(long) != 8 || sizeof(*(lock)) != 8))       \
			__unsupported_argument_size_for_pl_jtoc__(__FILE__,__LINE__);          \
	})                                                                                     \
)

/* Upgrade R to C. Inc(W) then wait for R==W or S != 0 */
#define pl_rtoc(lock) (                                                                        \
	(sizeof(long) == 8 && sizeof(*(lock)) == 8) ? ({                                       \
		register unsigned long *__lk_r = (unsigned long *)(lock);                      \
		register unsigned long __pl_r = pl_xadd(__lk_r, PLOCK64_WL_1) + PLOCK64_WL_1;  \
		register unsigned char __m = 0;                                                \
		while (__builtin_expect(!(__pl_r & PLOCK64_SL_ANY), 0)) {                      \
			unsigned char __loops;                                                 \
			if (__pl_r / PLOCK64_WL_1 == (__pl_r & PLOCK64_RL_ANY) / PLOCK64_RL_1) { \
				pl_or(__lk_r, PLOCK64_SL_1);                                   \
				break;                                                         \
			}                                                                      \
			__loops = __m + 1;                                                     \
			__m = (__m << 1) + 1;                                                  \
			do {                                                                   \
				pl_cpu_relax();                                                \
				pl_cpu_relax();                                                \
			} while (--__loops);                                                   \
			__pl_r = pl_deref_long(__lk_r);                                        \
		}                                                                              \
		pl_barrier();                                                                  \
	}) : (sizeof(*(lock)) == 4) ? ({                                                       \
		register unsigned int *__lk_r = (unsigned int *)(lock);                        \
		register unsigned int __pl_r = pl_xadd(__lk_r, PLOCK32_WL_1) + PLOCK32_WL_1;   \
		register unsigned char __m = 0;                                                \
		while (__builtin_expect(!(__pl_r & PLOCK32_SL_ANY), 0)) {                      \
			unsigned char __loops;                                                 \
			if (__pl_r / PLOCK32_WL_1 == (__pl_r & PLOCK32_RL_ANY) / PLOCK32_RL_1) { \
				pl_or(__lk_r, PLOCK32_SL_1);                                   \
				break;                                                         \
			}                                                                      \
			__loops = __m + 1;                                                     \
			__m = (__m << 1) + 1;                                                  \
			do {                                                                   \
				pl_cpu_relax();                                                \
				pl_cpu_relax();                                                \
			} while (--__loops);                                                   \
			__pl_r = pl_deref_int(__lk_r);                                         \
		}                                                                              \
		pl_barrier();                                                                  \
	}) : ({                                                                                \
		void __unsupported_argument_size_for_pl_rtoj__(char *,int);                    \
		if (sizeof(*(lock)) != 4 && (sizeof(long) != 8 || sizeof(*(lock)) != 8))       \
			__unsupported_argument_size_for_pl_rtoj__(__FILE__,__LINE__);          \
	})                                                                                     \
)

/* Drop the claim (C) lock : R--,W-- then clear S if !R */
#define pl_drop_c(lock) (                                                                      \
	(sizeof(long) == 8 && sizeof(*(lock)) == 8) ? ({                                       \
		register unsigned long *__lk_r = (unsigned long *)(lock);                      \
		register unsigned long __set_r = - PLOCK64_RL_1 - PLOCK64_WL_1;                \
		register unsigned long __pl_r = pl_xadd(__lk_r, __set_r) + __set_r;            \
		if (!(__pl_r & PLOCK64_RL_ANY))                                                \
			pl_and(__lk_r, ~PLOCK64_SL_1);                                         \
		pl_barrier();                                                                  \
	}) : (sizeof(*(lock)) == 4) ? ({                                                       \
		register unsigned int *__lk_r = (unsigned int *)(lock);                        \
		register unsigned int __set_r = - PLOCK32_RL_1 - PLOCK32_WL_1;                 \
		register unsigned int __pl_r = pl_xadd(__lk_r, __set_r) + __set_r;             \
		if (!(__pl_r & PLOCK32_RL_ANY))                                                \
			pl_and(__lk_r, ~PLOCK32_SL_1);                                         \
		pl_barrier();                                                                  \
	}) : ({                                                                                \
		void __unsupported_argument_size_for_pl_drop_c__(char *,int);                  \
		if (sizeof(*(lock)) != 4 && (sizeof(long) != 8 || sizeof(*(lock)) != 8))       \
			__unsupported_argument_size_for_pl_drop_c__(__FILE__,__LINE__);        \
	})                                                                                     \
)

/* Upgrade C to A. R-- then wait for !S or clear S if !R */
#define pl_ctoa(lock) (                                                                        \
	(sizeof(long) == 8 && sizeof(*(lock)) == 8) ? ({                                       \
		register unsigned long *__lk_r = (unsigned long *)(lock);                      \
		register unsigned long __pl_r = pl_xadd(__lk_r, -PLOCK64_RL_1) - PLOCK64_RL_1; \
		while (__pl_r & PLOCK64_SL_ANY) {                                              \
			if (!(__pl_r & PLOCK64_RL_ANY)) {                                      \
				pl_and(__lk_r, ~PLOCK64_SL_1);                                 \
				break;                                                         \
			}                                                                      \
			pl_cpu_relax();                                                        \
			pl_cpu_relax();                                                        \
			__pl_r = pl_deref_long(__lk_r);                                        \
		}                                                                              \
		pl_barrier();                                                                  \
	}) : (sizeof(*(lock)) == 4) ? ({                                                       \
		register unsigned int *__lk_r = (unsigned int *)(lock);                        \
		register unsigned int __pl_r = pl_xadd(__lk_r, -PLOCK32_RL_1) - PLOCK32_RL_1;  \
		while (__pl_r & PLOCK32_SL_ANY) {                                              \
			if (!(__pl_r & PLOCK32_RL_ANY)) {                                      \
				pl_and(__lk_r, ~PLOCK32_SL_1);                                 \
				break;                                                         \
			}                                                                      \
			pl_cpu_relax();                                                        \
			pl_cpu_relax();                                                        \
			__pl_r = pl_deref_int(__lk_r);                                         \
		}                                                                              \
		pl_barrier();                                                                  \
	}) : ({                                                                                \
		void __unsupported_argument_size_for_pl_ctoa__(char *,int);                    \
		if (sizeof(*(lock)) != 4 && (sizeof(long) != 8 || sizeof(*(lock)) != 8))       \
			__unsupported_argument_size_for_pl_ctoa__(__FILE__,__LINE__);          \
	})                                                                                     \
)

/* downgrade the atomic write access lock (A) to join (J) */
#define pl_atoj(lock) (                                                                        \
	(sizeof(long) == 8 && sizeof(*(lock)) == 8) ? ({                                       \
		pl_barrier();                                                                  \
		pl_add(lock, PLOCK64_RL_1);                                                    \
	}) : (sizeof(*(lock)) == 4) ? ({                                                       \
		pl_barrier();                                                                  \
		pl_add(lock, PLOCK32_RL_1);                                                    \
	}) : ({                                                                                \
		void __unsupported_argument_size_for_pl_atoj__(char *,int);                    \
		if (sizeof(*(lock)) != 4 && (sizeof(long) != 8 || sizeof(*(lock)) != 8))       \
			__unsupported_argument_size_for_pl_atoj__(__FILE__,__LINE__);          \
	})                                                                                     \
)

/* Returns non-zero if the thread calling it is the last writer, otherwise zero. It is
 * designed to be called before pl_drop_j(), pl_drop_c() or pl_drop_a() for operations
 * which need to be called only once.
 */
#define pl_last_writer(lock) (                                                                 \
	(sizeof(long) == 8 && sizeof(*(lock)) == 8) ? ({                                       \
		!(pl_deref_long(lock) & PLOCK64_WL_2PL);                                       \
	}) : (sizeof(*(lock)) == 4) ? ({                                                       \
		!(pl_deref_int(lock) & PLOCK32_WL_2PL);                                        \
	}) : ({                                                                                \
		void __unsupported_argument_size_for_pl_last_j__(char *,int);                  \
		if (sizeof(*(lock)) != 4 && (sizeof(long) != 8 || sizeof(*(lock)) != 8))       \
			__unsupported_argument_size_for_pl_last_j__(__FILE__,__LINE__);        \
		0;                                                                             \
	})                                                                                     \
)

/* attempt to get an exclusive write access via the J lock and wait for it.
 * Only one thread may succeed in this operation. It will not conflict with
 * other users and will first wait for all writers to leave, then for all
 * readers to leave before starting. This offers a solution to obtain an
 * exclusive access to a shared resource in the R/J/C/A model. A concurrent
 * take_a() will wait for this one to finish first. Using a CAS instead of XADD
 * should make the operation converge slightly faster. Returns non-zero on
 * success otherwise 0.
 */
#define pl_try_j(lock) (                                                                       \
	(sizeof(long) == 8 && sizeof(*(lock)) == 8) ? ({                                       \
		register unsigned long *__lk_r = (unsigned long *)(lock);                      \
		register unsigned long __set_r = PLOCK64_WL_1 | PLOCK64_RL_1;                  \
		register unsigned long __msk_r = PLOCK64_WL_ANY;                               \
		register unsigned long __pl_r;                                                 \
		register unsigned char __m;                                                    \
		pl_wait_unlock_long(__lk_r, __msk_r);                                          \
		__pl_r = pl_xadd(__lk_r, __set_r) + __set_r;                                   \
		/* wait for all other readers to leave */                                      \
		__m = 0;                                                                       \
		while (__builtin_expect(__pl_r & PLOCK64_RL_2PL, 0)) {                         \
			unsigned char __loops;                                                 \
			/* give up on other writers */                                         \
			if (__builtin_expect(__pl_r & PLOCK64_WL_2PL, 0)) {                    \
				pl_sub(__lk_r, __set_r);                                       \
				__pl_r = 0; /* failed to get the lock */                       \
				break;                                                         \
			}                                                                      \
			__loops = __m + 1;                                                     \
			__m = (__m << 1) + 1;                                                  \
			do {                                                                   \
				pl_cpu_relax();                                                \
				pl_cpu_relax();                                                \
			} while (--__loops);                                                   \
			__pl_r = pl_deref_long(__lk_r);                                        \
		}                                                                              \
		pl_barrier();                                                                  \
		__pl_r; /* return value, cannot be null on success */                          \
	}) : (sizeof(*(lock)) == 4) ? ({                                                       \
		register unsigned int *__lk_r = (unsigned int *)(lock);                        \
		register unsigned int __set_r = PLOCK32_WL_1 | PLOCK32_RL_1;                   \
		register unsigned int __msk_r = PLOCK32_WL_ANY;                                \
		register unsigned int __pl_r;                                                  \
		register unsigned char __m;                                                    \
		pl_wait_unlock_int(__lk_r, __msk_r);                                           \
		__pl_r = pl_xadd(__lk_r, __set_r) + __set_r;                                   \
		/* wait for all other readers to leave */                                      \
		__m = 0;                                                                       \
		while (__builtin_expect(__pl_r & PLOCK32_RL_2PL, 0)) {                         \
			unsigned char __loops;                                                 \
			/* but rollback on other writers */                                    \
			if (__builtin_expect(__pl_r & PLOCK32_WL_2PL, 0)) {                    \
				pl_sub(__lk_r, __set_r);                                       \
				__pl_r = 0; /* failed to get the lock */                       \
				break;                                                         \
			}                                                                      \
			__loops = __m + 1;                                                     \
			__m = (__m << 1) + 1;                                                  \
			do {                                                                   \
				pl_cpu_relax();                                                \
				pl_cpu_relax();                                                \
			} while (--__loops);                                                   \
			__pl_r = pl_deref_int(__lk_r);                                         \
		}                                                                              \
		pl_barrier();                                                                  \
		__pl_r; /* return value, cannot be null on success */                          \
	}) : ({                                                                                \
		void __unsupported_argument_size_for_pl_try_j__(char *,int);                   \
		if (sizeof(*(lock)) != 4 && (sizeof(long) != 8 || sizeof(*(lock)) != 8))       \
			__unsupported_argument_size_for_pl_try_j__(__FILE__,__LINE__);         \
		0;                                                                             \
	})                                                                                     \
)

/* request an exclusive write access via the J lock and wait for it. Only one
 * thread may succeed in this operation. It will not conflict with other users
 * and will first wait for all writers to leave, then for all readers to leave
 * before starting. This offers a solution to obtain an exclusive access to a
 * shared resource in the R/J/C/A model. A concurrent take_a() will wait for
 * this one to finish first. Using a CAS instead of XADD should make the
 * operation converge slightly faster.
 */
#define pl_take_j(lock) (                                                                      \
	(sizeof(long) == 8 && sizeof(*(lock)) == 8) ? ({                                       \
		__label__ __retry;                                                             \
		register unsigned long *__lk_r = (unsigned long *)(lock);                      \
		register unsigned long __set_r = PLOCK64_WL_1 | PLOCK64_RL_1;                  \
		register unsigned long __msk_r = PLOCK64_WL_ANY;                               \
		register unsigned long __pl_r;                                                 \
		register unsigned char __m;                                                    \
	__retry:                                                                               \
		pl_wait_unlock_long(__lk_r, __msk_r);                                          \
		__pl_r = pl_xadd(__lk_r, __set_r) + __set_r;                                   \
		/* wait for all other readers to leave */                                      \
		__m = 0;                                                                       \
		while (__builtin_expect(__pl_r & PLOCK64_RL_2PL, 0)) {                         \
			unsigned char __loops;                                                 \
			/* but rollback on other writers */                                    \
			if (__builtin_expect(__pl_r & PLOCK64_WL_2PL, 0)) {                    \
				pl_sub(__lk_r, __set_r);                                       \
				goto __retry;                                                  \
			}                                                                      \
			__loops = __m + 1;                                                     \
			__m = (__m << 1) + 1;                                                  \
			do {                                                                   \
				pl_cpu_relax();                                                \
				pl_cpu_relax();                                                \
			} while (--__loops);                                                   \
			__pl_r = pl_deref_long(__lk_r);                                        \
		}                                                                              \
		pl_barrier();                                                                  \
		0;                                                                             \
	}) : (sizeof(*(lock)) == 4) ? ({                                                       \
		__label__ __retry;                                                             \
		register unsigned int *__lk_r = (unsigned int *)(lock);                        \
		register unsigned int __set_r = PLOCK32_WL_1 | PLOCK32_RL_1;                   \
		register unsigned int __msk_r = PLOCK32_WL_ANY;                                \
		register unsigned int __pl_r;                                                  \
		register unsigned char __m;                                                    \
	__retry:                                                                               \
		pl_wait_unlock_int(__lk_r, __msk_r);                                           \
		__pl_r = pl_xadd(__lk_r, __set_r) + __set_r;                                   \
		/* wait for all other readers to leave */                                      \
		__m = 0;                                                                       \
		while (__builtin_expect(__pl_r & PLOCK32_RL_2PL, 0)) {                         \
			unsigned char __loops;                                                 \
			/* but rollback on other writers */                                    \
			if (__builtin_expect(__pl_r & PLOCK32_WL_2PL, 0)) {                    \
				pl_sub(__lk_r, __set_r);                                       \
				goto __retry;                                                  \
			}                                                                      \
			__loops = __m + 1;                                                     \
			__m = (__m << 1) + 1;                                                  \
			do {                                                                   \
				pl_cpu_relax();                                                \
				pl_cpu_relax();                                                \
			} while (--__loops);                                                   \
			__pl_r = pl_deref_int(__lk_r);                                         \
		}                                                                              \
		pl_barrier();                                                                  \
		0;                                                                             \
	}) : ({                                                                                \
		void __unsupported_argument_size_for_pl_take_j__(char *,int);                  \
		if (sizeof(*(lock)) != 4 && (sizeof(long) != 8 || sizeof(*(lock)) != 8))       \
			__unsupported_argument_size_for_pl_take_j__(__FILE__,__LINE__);        \
		0;                                                                             \
	})                                                                                     \
)

/* drop the join (J) lock entirely */
#define pl_drop_j(lock) (                                                                      \
	(sizeof(long) == 8 && sizeof(*(lock)) == 8) ? ({                                       \
		pl_barrier();                                                                  \
		pl_sub(lock, PLOCK64_WL_1 | PLOCK64_RL_1);                                     \
	}) : (sizeof(*(lock)) == 4) ? ({                                                       \
		pl_barrier();                                                                  \
		pl_sub(lock, PLOCK32_WL_1 | PLOCK32_RL_1);                                     \
	}) : ({                                                                                \
		void __unsupported_argument_size_for_pl_drop_j__(char *,int);                  \
		if (sizeof(*(lock)) != 4 && (sizeof(long) != 8 || sizeof(*(lock)) != 8))       \
			__unsupported_argument_size_for_pl_drop_j__(__FILE__,__LINE__);        \
	})                                                                                     \
)

/*
 * The part below is for Low Overhead R/W locks (LORW). These ones are not
 * upgradable and not necessarily fair but they try to be fast when uncontended
 * and to limit the cost and perturbation during contention. Writers always
 * have precedence over readers to preserve latency as much as possible.
 *
 * The principle is to offer a fast no-contention path and a limited total
 * number of writes for the contended path. Since R/W locks are expected to be
 * used in situations where there is a benefit in separating reads from writes,
 * it is expected that reads are common (typ >= 50%) and that there is often at
 * least one reader (otherwise a spinlock wouldn't be a problem). As such, a
 * reader will try to pass instantly, detect contention and immediately retract
 * and wait in the queue in case there is contention. A writer will first also
 * try to pass instantly, and if it fails due to pending readers, it will mark
 * that it's waiting so that readers stop entering. This will leave the writer
 * waiting as close as possible to the point of being granted access. New
 * writers will also notice this previous contention and will wait outside.
 * This means that a successful access for a reader or a writer requires a
 * single CAS, and a contended attempt will require one failed CAS and one
 * successful XADD for a reader, or an optional OR and a N+1 CAS for the
 * writer.
 *
 * A counter of shared users indicates the number of active readers, while a
 * (single-bit) counter of exclusive writers indicates whether the lock is
 * currently held for writes. This distinction also permits to use a single
 * function to release the lock if desired, since the exclusive bit indicates
 * the state of the caller of unlock(). The WRQ bit is cleared during the
 * unlock.
 *
 * Layout: (32/64 bit):
 *                      31           2   1     0
 *         +-----------+--------------+-----+-----+
 *         |           |     SHR      | WRQ | EXC |
 *         +-----------+--------------+-----+-----+
 *
 * In order to minimize operations, the WRQ bit is held during EXC so that the
 * write waiter that had to fight for EXC doesn't have to release WRQ during
 * its operations, and will just drop it along with EXC upon unlock.
 *
 * This means the following costs:
 *   reader:
 *      success: 1 CAS
 *      failure: 1 CAS + 1 XADD
 *      unlock:  1 SUB
 *   writer:
 *      success: 1 RD + 1 CAS
 *      failure: 1 RD + 1 CAS + 0/1 OR + N CAS
 *      unlock:  1 AND
 */

#define PLOCK_LORW_EXC_BIT    ((sizeof(long) == 8) ?  0 :  0)
#define PLOCK_LORW_EXC_SIZE   ((sizeof(long) == 8) ?  1 :  1)
#define PLOCK_LORW_EXC_BASE   (1UL << PLOCK_LORW_EXC_BIT)
#define PLOCK_LORW_EXC_MASK   (((1UL << PLOCK_LORW_EXC_SIZE) - 1UL) << PLOCK_LORW_EXC_BIT)

#define PLOCK_LORW_WRQ_BIT    ((sizeof(long) == 8) ?  1 :  1)
#define PLOCK_LORW_WRQ_SIZE   ((sizeof(long) == 8) ?  1 :  1)
#define PLOCK_LORW_WRQ_BASE   (1UL << PLOCK_LORW_WRQ_BIT)
#define PLOCK_LORW_WRQ_MASK   (((1UL << PLOCK_LORW_WRQ_SIZE) - 1UL) << PLOCK_LORW_WRQ_BIT)

#define PLOCK_LORW_SHR_BIT    ((sizeof(long) == 8) ?  2 :  2)
#define PLOCK_LORW_SHR_SIZE   ((sizeof(long) == 8) ? 30 : 30)
#define PLOCK_LORW_SHR_BASE   (1UL << PLOCK_LORW_SHR_BIT)
#define PLOCK_LORW_SHR_MASK   (((1UL << PLOCK_LORW_SHR_SIZE) - 1UL) << PLOCK_LORW_SHR_BIT)

__attribute__((unused,always_inline,no_instrument_function))
static inline void pl_lorw_rdlock(unsigned long *lock)
{
	unsigned long lk = 0;

	/* First, assume we're alone and try to get the read lock (fast path).
	 * It often works because read locks are often used on low-contention
	 * structs.
	 */
	lk = pl_cmpxchg(lock, 0, PLOCK_LORW_SHR_BASE);
	if (!lk)
		return;

	/* so we were not alone, make sure there's no writer waiting for the
	 * lock to be empty of visitors.
	 */
	if (lk & PLOCK_LORW_WRQ_MASK)
		lk = pl_wait_unlock_long(lock, PLOCK_LORW_WRQ_MASK);

	/* count us as visitor among others */
	lk = pl_xadd(lock, PLOCK_LORW_SHR_BASE);

	/* wait for end of exclusive access if any */
	if (lk & PLOCK_LORW_EXC_MASK)
		lk = pl_wait_unlock_long(lock, PLOCK_LORW_EXC_MASK);
}


__attribute__((unused,always_inline,no_instrument_function))
static inline void pl_lorw_wrlock(unsigned long *lock)
{
	unsigned long lk = 0;
	unsigned long old = 0;

	/* first, make sure another writer is not already blocked waiting for
	 * readers to leave. Note that tests have shown that it can be even
	 * faster to avoid the first check and to unconditionally wait.
	 */
	lk = pl_deref_long(lock);
	if (__builtin_expect(lk & PLOCK_LORW_WRQ_MASK, 1))
		lk = pl_wait_unlock_long(lock, PLOCK_LORW_WRQ_MASK);

	do {
		/* let's check for the two sources of contention at once */

		if (__builtin_expect(lk & (PLOCK_LORW_SHR_MASK | PLOCK_LORW_EXC_MASK), 1)) {
			/* check if there are still readers coming. If so, close the door and
			 * wait for them to leave.
			 */
			if (lk & PLOCK_LORW_SHR_MASK) {
				/* note below, an OR is significantly cheaper than BTS or XADD */
				if (!(lk & PLOCK_LORW_WRQ_MASK))
					pl_or(lock, PLOCK_LORW_WRQ_BASE);
				lk = pl_wait_unlock_long(lock, PLOCK_LORW_SHR_MASK);
			}

			/* And also wait for a previous writer to finish. */
			if (lk & PLOCK_LORW_EXC_MASK)
				lk = pl_wait_unlock_long(lock, PLOCK_LORW_EXC_MASK);
		}

		/* A fresh new reader may appear right now if there were none
		 * above and we didn't close the door.
		 */
		old = lk & ~PLOCK_LORW_SHR_MASK & ~PLOCK_LORW_EXC_MASK;
		lk = pl_cmpxchg(lock, old, old | PLOCK_LORW_EXC_BASE);
	} while (lk != old);

	/* done, not waiting anymore, the WRQ bit if any, will be dropped by the
	 * unlock
	 */
}


__attribute__((unused,always_inline,no_instrument_function))
static inline void pl_lorw_rdunlock(unsigned long *lock)
{
	pl_sub(lock, PLOCK_LORW_SHR_BASE);
}

__attribute__((unused,always_inline,no_instrument_function))
static inline void pl_lorw_wrunlock(unsigned long *lock)
{
	pl_and(lock, ~(PLOCK_LORW_WRQ_MASK | PLOCK_LORW_EXC_MASK));
}

__attribute__((unused,always_inline,no_instrument_function))
static inline void pl_lorw_unlock(unsigned long *lock)
{
	if (pl_deref_long(lock) & PLOCK_LORW_EXC_MASK)
		pl_lorw_wrunlock(lock);
	else
		pl_lorw_rdunlock(lock);
}

#endif /* PL_PLOCK_H */
