[svn-commits] gtjoseph: branch 12 r412976 - in /branches/12: ./ include/asterisk/

SVN commits to the Digium repositories svn-commits at lists.digium.com
Wed Apr 23 15:06:15 CDT 2014


Author: gtjoseph
Date: Wed Apr 23 15:06:03 2014
New Revision: 412976

URL: http://svnview.digium.com/svn/asterisk?view=rev&rev=412976
Log:
This patch adds support for spinlocks in Asterisk.

There are cases in Asterisk where it might be desirable to lock
a short critical code section but not incur the context switch
and yield penalty of a mutex or rwlock.  The primary spinlock
implementations execute exclusively in userspace and therefore
don't incur those penalties.  Spinlocks are NOT meant to be a
general replacement for mutexes.  They should be used only for
protecting short blocks of critical code such as simple compares
and assignments.  Operations that may block, hold a lock, or
cause the thread to give up it's timeslice should NEVER be
attempted in a spinlock.

The first use case for spinlocks is in astobj2 - internal_ao2_ref.
Currently the manipulation of the reference counter is done with
an ast_atomic_fetchadd_int which works fine.  When weak reference
containers are introduced however, there's an additional comparison
and assignment that'll need to be done while the lock is held.
A mutex would be way too expensive here, hence the spinlock.
Given that lock contention in this situation would be infrequent,
the overhead of the spinlock is only a few more machine instructions
than the current ast_atomic_fetchadd_int call.

ASTERISK-23553 #close
Review: https://reviewboard.asterisk.org/r/3405/

Added:
    branches/12/include/asterisk/spinlock.h   (with props)
Modified:
    branches/12/configure
    branches/12/configure.ac
    branches/12/include/asterisk/autoconfig.h.in

Modified: branches/12/configure.ac
URL: http://svnview.digium.com/svn/asterisk/branches/12/configure.ac?view=diff&rev=412976&r1=412975&r2=412976
==============================================================================
--- branches/12/configure.ac (original)
+++ branches/12/configure.ac Wed Apr 23 15:06:03 2014
@@ -818,6 +818,22 @@
 AC_MSG_RESULT(no)
 )
 
+AC_MSG_CHECKING(for PTHREAD_MUTEX_ADAPTIVE_NP in pthread.h)
+AC_LINK_IFELSE(
+[AC_LANG_PROGRAM([#include <pthread.h>], [int a = PTHREAD_MUTEX_ADAPTIVE_NP;])],
+AC_MSG_RESULT(yes)
+AC_DEFINE([HAVE_PTHREAD_MUTEX_ADAPTIVE_NP], 1, [Define to 1 if your system defines PTHREAD_MUTEX_ADAPTIVE_NP in pthread.h]),
+AC_MSG_RESULT(no)
+)
+
+AC_MSG_CHECKING(for pthread_spinlock_t in pthread.h)
+AC_LINK_IFELSE(
+[AC_LANG_PROGRAM([#include <pthread.h>], [pthread_spinlock_t spin;])],
+AC_MSG_RESULT(yes)
+AC_DEFINE([HAVE_PTHREAD_SPINLOCK], 1, [Define to 1 if your system has pthread_spinlock_t in pthread.h]),
+AC_MSG_RESULT(no)
+)
+
 save_LIBS="$LIBS"
 save_CFLAGS="$CFLAGS"
 LIBS="$PTHREAD_LIBS $LIBS"

Modified: branches/12/include/asterisk/autoconfig.h.in
URL: http://svnview.digium.com/svn/asterisk/branches/12/include/asterisk/autoconfig.h.in?view=diff&rev=412976&r1=412975&r2=412976
==============================================================================
--- branches/12/include/asterisk/autoconfig.h.in (original)
+++ branches/12/include/asterisk/autoconfig.h.in Wed Apr 23 15:06:03 2014
@@ -667,6 +667,10 @@
 /* Define if you have POSIX threads libraries and header files. */
 #undef HAVE_PTHREAD
 
+/* Define to 1 if your system defines PTHREAD_MUTEX_ADAPTIVE_NP in pthread.h
+   */
+#undef HAVE_PTHREAD_MUTEX_ADAPTIVE_NP
+
 /* Define to 1 if your system defines PTHREAD_MUTEX_RECURSIVE_NP in pthread.h
    */
 #undef HAVE_PTHREAD_MUTEX_RECURSIVE_NP
@@ -684,6 +688,9 @@
 
 /* Define if your system has pthread_rwlock_timedwrlock() */
 #undef HAVE_PTHREAD_RWLOCK_TIMEDWRLOCK
+
+/* Define to 1 if your system has pthread_spinlock_t in pthread.h */
+#undef HAVE_PTHREAD_SPINLOCK
 
 /* Define to 1 if the system has the type `ptrdiff_t'. */
 #undef HAVE_PTRDIFF_T

Added: branches/12/include/asterisk/spinlock.h
URL: http://svnview.digium.com/svn/asterisk/branches/12/include/asterisk/spinlock.h?view=auto&rev=412976
==============================================================================
--- branches/12/include/asterisk/spinlock.h (added)
+++ branches/12/include/asterisk/spinlock.h Wed Apr 23 15:06:03 2014
@@ -1,0 +1,445 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 2014, Fairview 5 Engineering, LLC
+ *
+ * George Joseph <george.joseph at fairview5.com>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*! \file
+ * \brief Spin Locks.
+ *
+ * In some atomic operation circumstances the __atomic calls are not quite
+ * flexible enough but a full fledged mutex or rwlock is too expensive.
+ *
+ * Spin locks should be used only for protecting short blocks of critical
+ * code such as simple compares and assignments.  Operations that may block,
+ * hold a lock, or cause the thread to give up it's timeslice should NEVER
+ * be attempted in a spin lock.
+ *
+ * Because spinlocks must be as lightweight as possible, there are no
+ * recursion or deadlock checks.
+ *
+ */
+
+#ifndef _ASTERISK_SPINLOCK_H
+#define _ASTERISK_SPINLOCK_H
+
+#include <pthread.h>
+#include "asterisk/compiler.h"
+
+/*!
+ * \brief Spinlock Implementation Types
+ *
+ * Not all implementations will be available on all platforms.
+ *
+ */
+enum ast_spinlock_type {
+	AST_SPINLOCK_TYPE_GCC_ATOMICS,
+	AST_SPINLOCK_TYPE_GAS_X86,
+	AST_SPINLOCK_TYPE_GAS_ARM,
+	AST_SPINLOCK_TYPE_GAS_SPARC,
+	AST_SPINLOCK_TYPE_OSX_ATOMICS,
+	AST_SPINLOCK_TYPE_PTHREAD_SPINLOCK,
+	AST_SPINLOCK_TYPE_PTHREAD_MUTEX,
+};
+
+/*!
+ * \brief Implementation using GCC Atomics
+ *
+ * Specifically, __sync_lock_test_and_set is used to atomically
+ * set/unset the lock variable.
+ *
+ * Most recent gcc implementations support this method and it's performance
+ * is equal to or better than the assembly implementations hence it is the
+ * most preferred implementation on all platforms.
+ *
+ */
+#ifdef HAVE_GCC_ATOMICS
+#define AST_SPINLOCK_TYPE AST_SPINLOCK_TYPE_GCC_ATOMICS
+#define AST_SPINLOCK_TYPE_LABEL "gcc_atomics"
+typedef volatile unsigned int ast_spinlock_t;
+
+static force_inline int ast_spinlock_init(ast_spinlock_t *lock)
+{
+	*lock = 0;
+	return 0;
+}
+
+static force_inline int ast_spinlock_lock(ast_spinlock_t *lock)
+{
+	while (__sync_lock_test_and_set(lock, 1)) {
+		while(*lock) {
+		}
+	}
+	return 0;
+}
+
+static force_inline int ast_spinlock_trylock(ast_spinlock_t *lock)
+{
+	return __sync_lock_test_and_set(lock, 1);
+}
+
+static force_inline int ast_spinlock_unlock(ast_spinlock_t *lock)
+{
+	__sync_lock_release(lock);
+	return 0;
+}
+#endif
+
+/*!
+ * \brief Implementation using x86 Assembly
+ *
+ * For x86 implementations that don't support gcc atomics,
+ * this is the next best method.
+ *
+ */
+#if (defined(__x86_64__) || defined(__i386__)) && !defined(AST_SPINLOCK_TYPE)
+#define AST_SPINLOCK_TYPE AST_SPINLOCK_TYPE_GAS_X86
+#define AST_SPINLOCK_TYPE_LABEL "gas_x86"
+typedef volatile unsigned int ast_spinlock_t;
+
+static force_inline int ast_spinlock_init(ast_spinlock_t *lock)
+{
+	*lock = 0;
+	return 0;
+}
+
+static force_inline int x86chgl(ast_spinlock_t *p, unsigned int v)
+{
+	__asm __volatile (
+		"	xchg   %0, %1 ;"
+		: "+r" (v), "=m" (*p)
+		: "m" (*p)
+	);
+
+	return (v);
+}
+
+static force_inline int ast_spinlock_lock(ast_spinlock_t *lock)
+{
+	while (x86chgl(lock, 1)) {
+		while(*lock) {
+		}
+	}
+	return 0;
+}
+
+static force_inline int ast_spinlock_trylock(ast_spinlock_t *lock)
+{
+	return x86chgl(lock, 1);
+}
+
+static force_inline int ast_spinlock_unlock(ast_spinlock_t *lock)
+{
+	x86chgl(lock, 0);
+	return 0;
+}
+#endif
+
+/*!
+ * \brief Implementation using ARM Assembly
+ *
+ * For ARM implementations that don't support gcc atomics,
+ * this is the next best method.
+ *
+ */
+#if defined(__arm__) && !defined(AST_SPINLOCK_TYPE)
+#define AST_SPINLOCK_TYPE AST_SPINLOCK_TYPE_GAS_ARM
+#define AST_SPINLOCK_TYPE_LABEL "gas_arm"
+typedef volatile unsigned int ast_spinlock_t;
+
+static force_inline int ast_spinlock_init(ast_spinlock_t *lock)
+{
+	*lock = 0;
+	return 0;
+}
+
+static force_inline int ast_spinlock_lock(ast_spinlock_t *lock)
+{
+	unsigned int tmp;
+
+	__asm __volatile (
+		"1:	ldrex %[tmp], %[lock];"
+		"	teq %[tmp], #0;"
+#if defined __ARM_ARCH && __ARM_ARCH >= 7
+		"	wfene;"
+#endif
+		"	strexeq %[tmp], %[c1], %[lock];"
+		"	teqeq %[tmp], #0;"
+		"	bne 1b;"
+		: [tmp] "=&r" (tmp)
+		: [lock] "m" (*lock) [c1] "r" (1)
+		: "cc"
+	);
+
+	return tmp;
+}
+
+static force_inline int ast_spinlock_trylock(ast_spinlock_t *lock)
+{
+	unsigned int tmp;
+
+	__asm __volatile (
+		"	ldrex %[tmp], %[lock];"
+		"	teq %[tmp], #0;"
+#if defined __ARM_ARCH && __ARM_ARCH >= 7
+		"	wfene;"
+#endif
+		"	strexeq %[tmp], %[c1], %[lock];"
+		: [tmp] "=&r" (tmp)
+		: [lock] "m" (*lock) [c1] "r" (1)
+		: "cc"
+	);
+
+	return tmp;
+}
+
+static force_inline int ast_spinlock_unlock(ast_spinlock_t *lock)
+{
+	__asm __volatile (
+		"	dmb;"
+		"	str %[c0], %[lock];"
+#if defined __ARM_ARCH && __ARM_ARCH >= 7
+		"	dsb;"
+		"	sev;"
+#endif
+		:
+		: [lock] "m" (*lock) [c0] "r" (0)
+		: "cc"
+	);
+
+	return 0;
+}
+#endif
+
+/*!
+ * \brief Implementation using Sparc Assembly
+ *
+ * For Sparc implementations that don't support gcc atomics,
+ * this is the next best method.
+ *
+ */
+#if defined(__sparc__) && !defined(AST_SPINLOCK_TYPE)
+#define AST_SPINLOCK_TYPE AST_SPINLOCK_TYPE_GAS_SPARC
+#define AST_SPINLOCK_TYPE_LABEL "gas_sparc"
+typedef volatile unsigned char ast_spinlock_t;
+
+static force_inline int ast_spinlock_init(ast_spinlock_t *lock)
+{
+	*lock = 0;
+	return 0;
+}
+
+static force_inline int ast_spinlock_lock(ast_spinlock_t *lock)
+{
+	unsigned char tmp;
+
+	__asm__ __volatile__(
+		"1:	ldstub		%[lock], %[tmp]\n"
+		"	brnz,pn		%[tmp], 2f\n"
+		"	 nop\n"
+		"	.subsection	2\n"
+		"2:	ldub		%[lock], %[tmp]\n"
+		"	brnz,pt		%[tmp], 2b\n"
+		"	 nop\n"
+		"	ba,a,pt		%%xcc, 1b\n"
+		"	.previous"
+		: [tmp] "=&r" (tmp)
+		: [lock] "m" (*lock)
+		: "memory"
+	);
+
+	return 0;
+}
+
+static force_inline int ast_spinlock_trylock(ast_spinlock_t *lock)
+{
+	unsigned long result = 1;
+
+	__asm__ __volatile__(
+		"	ldstub		%[lock], %[result]\n"
+		: [result] "=&r" (result)
+		: [lock] "m" (*lock)
+		: "memory", "cc"
+	);
+
+	return (result != 0);
+}
+
+static force_inline int ast_spinlock_unlock(ast_spinlock_t *lock)
+{
+	__asm__ __volatile__(
+		"	stb		%%g0, %[lock]"
+		:
+		: [lock] "m" (*lock)
+		: "memory", "cc"
+	);
+
+	return 0;
+}
+#endif
+
+/*!
+ * \brief Implementation using pthread_spinlock
+ *
+ * pthread_spinlocks are not supported on all platforms
+ * but if for some reason none of the previous implementations are
+ * available, it can be used with reasonable performance.
+ *
+ */
+#if defined (HAVE_PTHREAD_SPINLOCK) && !defined(AST_SPINLOCK_TYPE)
+#define AST_SPINLOCK_TYPE AST_SPINLOCK_TYPE_PTHREAD_SPINLOCK
+#define AST_SPINLOCK_TYPE_LABEL "pthread_spinlock"
+typedef pthread_spinlock_t ast_spinlock_t;
+
+static force_inline int ast_spinlock_init(ast_spinlock_t *lock)
+{
+	return pthread_spin_init(lock, PTHREAD_PROCESS_PRIVATE);
+}
+
+static force_inline int ast_spinlock_lock(ast_spinlock_t *lock)
+{
+	return pthread_spin_lock(lock);
+}
+
+static force_inline int ast_spinlock_trylock(ast_spinlock_t *lock)
+{
+	return pthread_spin_trylock(lock);
+}
+
+static force_inline int ast_spinlock_unlock(ast_spinlock_t *lock)
+{
+	return pthread_spin_unlock(lock);
+}
+#endif
+
+/*!
+ * \brief Implementation using OSX Atomics
+ *
+ * The Darwin/Mac OSX platform has its own atomics
+ * implementation but it uses more kernel time than
+ * GCC atomics and x86 assembly.  It is included
+ * as an unlikely fallback.
+ *
+ */
+#if defined(HAVE_OSX_ATOMICS) && !defined(AST_SPINLOCK_TYPE)
+#include <libkern/OSAtomic.h>
+#define AST_SPINLOCK_TYPE AST_SPINLOCK_TYPE_OSX_ATOMICS
+#define AST_SPINLOCK_TYPE_LABEL "osx_atomics"
+typedef OSSpinLock ast_spinlock_t;
+
+static force_inline int ast_spinlock_init(ast_spinlock_t *lock)
+{
+	*lock = OS_SPINLOCK_INIT;
+	return 0;
+}
+
+static force_inline int ast_spinlock_lock(ast_spinlock_t *lock)
+{
+	OSSpinLockLock(lock);
+	return 0;
+}
+
+static force_inline int ast_spinlock_trylock(ast_spinlock_t *lock)
+{
+	return !OSSpinLockTry(lock);
+}
+
+static force_inline int ast_spinlock_unlock(ast_spinlock_t *lock)
+{
+	OSSpinLockUnlock(lock);
+	return 0;
+}
+#endif
+
+/*!
+ * \brief Implementation using pthread_mutex
+ *
+ * pthread_mutex is supported on all platforms but
+ * it is also the worst performing. It is included
+ * as an unlikely fallback.
+ *
+ */
+#if !defined(AST_SPINLOCK_TYPE)
+#define AST_SPINLOCK_TYPE AST_SPINLOCK_TYPE_PTHREAD_MUTEX
+#define AST_SPINLOCK_TYPE_LABEL "pthread_mutex"
+typedef pthread_mutex_t ast_spinlock_t;
+
+static force_inline int ast_spinlock_init(ast_spinlock_t *lock)
+{
+	pthread_mutex_init(lock, NULL);
+	return 0;
+}
+
+static force_inline int ast_spinlock_lock(ast_spinlock_t *lock)
+{
+	return pthread_mutex_lock(lock);
+}
+
+static force_inline int ast_spinlock_trylock(ast_spinlock_t *lock)
+{
+	return pthread_mutex_trylock(lock);
+}
+
+static force_inline int ast_spinlock_unlock(ast_spinlock_t *lock)
+{
+	return pthread_mutex_unlock(lock);
+}
+#endif
+
+#if !defined(AST_SPINLOCK_TYPE)
+#error "No spinlock implementation could be found."
+#endif
+
+/* Prototypes are declared here to insure that each implementation provides
+ * the same API and to act as placeholders for the documentation.
+ */
+
+/*!
+ * \brief Initialize a spin lock
+ * \param lock Address of the lock
+ * \retval 0 Success
+ * \retval other Failure
+ */
+static force_inline int ast_spinlock_init(ast_spinlock_t *lock);
+
+/*!
+ * \brief Lock a spin lock
+ * \param lock Address of the lock
+ * \retval 0 Success
+ * \retval other Failure
+ */
+static force_inline int ast_spinlock_lock(ast_spinlock_t *lock);
+
+/*!
+ * \brief Try to lock a spin lock
+ *
+ * Attempt to gain a lock.  Return immediately
+ * regardless of result.
+ *
+ * \param lock Address of the lock
+ * \retval 0 Success
+ * \retval other Lock was not obtained
+ */
+static force_inline int ast_spinlock_trylock(ast_spinlock_t *lock);
+
+/*!
+ * \brief Unlock a spin lock
+ * \param lock Address of the lock
+ * \retval 0 Success
+ * \retval other Failure
+ */
+static force_inline int ast_spinlock_unlock(ast_spinlock_t *lock);
+
+#endif /* _ASTERISK_SPINLOCK_H */

Propchange: branches/12/include/asterisk/spinlock.h
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: branches/12/include/asterisk/spinlock.h
------------------------------------------------------------------------------
    svn:keywords = Author Date Id Rev URL

Propchange: branches/12/include/asterisk/spinlock.h
------------------------------------------------------------------------------
    svn:mime-type = text/plain




More information about the svn-commits mailing list