arch/powerpc/spinlock.h

/*
 * PowerPC spinlock operations.
 * With the help of various source: Darwin, Linux kernel...
 *
 * $Id: spinlock.h.in,v 1.1 2007/05/24 12:54:10 mbuna Exp $
 */
#ifndef INCLUDED_PEAK_SPINLOCK_H_
#define INCLUDED_PEAK_SPINLOCK_H_

#define PEAK_SPINLOCK_ITERATIONS 1000

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <sys/types.h>
#include <sys/time.h>
#include <sys/signal.h>
#include <pthread.h>
#include <unistd.h>
#ifdef HAVE_SCHED_H
#include <sched.h>
#endif
#ifdef HAVE_ATOMIC_OP_H
#include <sys/atomic_op.h> /* AIX */
#endif

#include <peak/stdint.h>

/* Erratum #77 on the 405 means we need a sync or dcbt before every stwcx.
 * The old ATOMIC_SYNC_FIX covered some but not all of this.
 */
#ifdef CONFIG_IBM405_ERR77
#define PPC405_ERR77(ra,rb)     "dcbt " #ra "," #rb ";"
#else
#define PPC405_ERR77(ra,rb)
#endif

/* PEAK defaults to SMP
 */
#ifdef PEAK_CONFIG_UNIPROCESSOR
#define SMP_WMB
#define SMP_MB
#else
#define SMP_WMB "eieio\n"
#define SMP_MB "\nsync"
#endif /* PEAK_CONFIG_UNIPROCESSOR */


#if defined(__cplusplus)
extern "C" {
#endif

/* PEAK INTERNAL SPIN LOCK
 * 
 * _peak_spinlock_lock(lockp)
 * _peak_spinlock_lock_try(lockp) - returns 0 (busy) or 1 (got the lock)
 * _peak_spinlock_unlock(lockp)
 * 
 */

extern int _peak_is_threaded;

#if defined(HAVE__SPIN_LOCK) && defined(HAVE__SPIN_LOCK_TRY) && defined(HAVE__SPIN_UNLOCK)
#define USE_DARWIN_SPINLOCK 1
#else
#define USE_DARWIN_SPINLOCK 0
#endif

/* Type and initializer for this architecture.
 */
#if USE_DARWIN_SPINLOCK
typedef volatile long peak_spinlock_t;
#define PEAK_SPINLOCK_INITIALIZER (0)
#elif defined(__GNUC__)
typedef struct { volatile unsigned long lock; } peak_spinlock_t;
#define PEAK_SPINLOCK_INITIALIZER ((peak_spinlock_t){ (0) })
#elif defined(_AIX)
typedef int peak_spinlock_t; /* AIX: typedef int     *atomic_p; */
#define PEAK_SPINLOCK_INITIALIZER (0)
#endif

#if USE_DARWIN_SPINLOCK
extern void _spin_lock(peak_spinlock_t *lockp);
extern int  _spin_lock_try(peak_spinlock_t *lockp);
extern void _spin_unlock(peak_spinlock_t *lockp);
#endif

static inline void
_peak_spinlock_lock(peak_spinlock_t *lockp)
  {
#if USE_DARWIN_SPINLOCK
  
  if (!_peak_is_threaded) /* set only if peak uses several threads */
    return;
  
  _spin_lock(lockp);   /* Lucky, we have a system function for that.
                        * I checked on Darwin 7.0 and it deals properly
                        * with 32 or 64 bit, UP (always depress) or
                        * MP (1000 spin tries before relinquish).
                        * On Darwin 6.x, however, the kernel use generic
                        * PPC MP code, but well.                 --mbuna
                        */
  
#elif defined(__GNUC__)
  
  unsigned long tmp;
  
  if (!_peak_is_threaded) /* set only if peak uses several threads */
    return;
  
  __asm__ __volatile__(
        "b      1f              # spin_lock\n\
2:      lwzx    %0,0,%1\n\
        cmpwi   0,%0,0\n\
        bne+    2b\n\
1:      lwarx   %0,0,%1\n\
        cmpwi   0,%0,0\n\
        bne-    2b\n"
        PPC405_ERR77(0,%1)
"       stwcx.  %2,0,%1\n\
        bne-    2b\n\
        isync"
        : "=&r"(tmp)
        : "r"(&lockp->lock), "r"(1)
        : "cr0", "memory");

#elif defined(_AIX)
  
  unsigned int tries = PEAK_SPINLOCK_ITERATIONS;
  
  if (!_peak_is_threaded) /* set only if peak uses several threads */
    return;
  
  while (!_check_lock(lockp, 0, 1))
    {
    if (--tries > 0)
      {
      sched_yield();
      tries = PEAK_SPINLOCK_ITERATIONS;
      }
    }
  
#else
#error _peak_spinlock_lock not supported
#endif /* USE_DARWIN_SPINLOCK */
  }

static inline int
_peak_spinlock_lock_try(peak_spinlock_t *lockp)
  {
#if USE_DARWIN_SPINLOCK
  if (!_peak_is_threaded) /* set only if peak uses several threads */
    return 1; /* always succeed */
  
  return _spin_lock_try(lockp);
#elif defined(__GNUC__)
  unsigned int old, t;
  unsigned int mask = 1;
  volatile unsigned int *p = ((volatile unsigned int *)lockp->lock);
  
  if (!_peak_is_threaded) /* set only if peak uses several threads */
    return 1; /* always succeed */
  
  __asm__ __volatile__(SMP_WMB "\n\
1:      lwarx   %0,0,%4 \n\
        or      %1,%0,%3 \n"
        PPC405_ERR77(0,%4)
"       stwcx.  %1,0,%4 \n\
        bne     1b"
        SMP_MB
        : "=&r" (old), "=&r" (t), "=m" (*p)
        : "r" (mask), "r" (p), "m" (*p)
        : "cc", "memory");
  
  return (old & mask) == 0;
#elif defined(_AIX)
  return !_check_lock(lockp, 0, 1);
#else
#error _peak_spinlock_lock_try not supported
#endif
  }

static inline void
_peak_spinlock_unlock(peak_spinlock_t *lockp)
  {
  if (!_peak_is_threaded) /* set only if peak uses several threads */
    return;
  
#if USE_DARWIN_SPINLOCK
  if (!_peak_is_threaded) /* set only if peak uses several threads */
    return;
  
  _spin_unlock(lockp);

#elif defined(__GNUC__)
  /* The eieio instruction is a faster sync: a barrier providing an ordering
   * (separately) for (a) cacheable stores and (b) loads and stores to
   * non-cacheable memory (e.g. I/O devices).
   */
  __asm__ __volatile__("eieio           # spin_unlock": : :"memory");
  lockp->lock = 0;
#elif defined(_AIX)
  _clear_lock(lockp, 0);
#else
#error _peak_spinlock_unlock not supported
#endif
  }

#if defined(__cplusplus)
}
#endif

#endif /* INCLUDED_PEAK_SPINLOCK_H_ */
Revision:	3251
Committed:	Wed Apr 2 16:58:30 2014 UTC (11 years, 4 months ago) by michael
Content type:	text/x-chdr
File size:	5188 byte(s)
Log Message:	- Imported libpeak-0.1.2
#	Content
1	/*
2	* PowerPC spinlock operations.
3	* With the help of various source: Darwin, Linux kernel...
4	*
5	* $Id: spinlock.h.in,v 1.1 2007/05/24 12:54:10 mbuna Exp $
6	*/
7	#ifndef INCLUDED_PEAK_SPINLOCK_H_
8	#define INCLUDED_PEAK_SPINLOCK_H_
9
10	#define PEAK_SPINLOCK_ITERATIONS 1000
11
12	#ifdef HAVE_CONFIG_H
13	#include "config.h"
14	#endif
15	#include <sys/types.h>
16	#include <sys/time.h>
17	#include <sys/signal.h>
18	#include <pthread.h>
19	#include <unistd.h>
20	#ifdef HAVE_SCHED_H
21	#include <sched.h>
22	#endif
23	#ifdef HAVE_ATOMIC_OP_H
24	#include <sys/atomic_op.h> /* AIX */
25	#endif
26
27	#include <peak/stdint.h>
28
29	/* Erratum #77 on the 405 means we need a sync or dcbt before every stwcx.
30	* The old ATOMIC_SYNC_FIX covered some but not all of this.
31	*/
32	#ifdef CONFIG_IBM405_ERR77
33	#define PPC405_ERR77(ra,rb) "dcbt " #ra "," #rb ";"
34	#else
35	#define PPC405_ERR77(ra,rb)
36	#endif
37
38	/* PEAK defaults to SMP
39	*/
40	#ifdef PEAK_CONFIG_UNIPROCESSOR
41	#define SMP_WMB
42	#define SMP_MB
43	#else
44	#define SMP_WMB "eieio\n"
45	#define SMP_MB "\nsync"
46	#endif /* PEAK_CONFIG_UNIPROCESSOR */
47
48
49	#if defined(__cplusplus)
50	extern "C" {
51	#endif
52
53	/* PEAK INTERNAL SPIN LOCK
54	*
55	* _peak_spinlock_lock(lockp)
56	* _peak_spinlock_lock_try(lockp) - returns 0 (busy) or 1 (got the lock)
57	* _peak_spinlock_unlock(lockp)
58	*
59	*/
60
61	extern int _peak_is_threaded;
62
63	#if defined(HAVE__SPIN_LOCK) && defined(HAVE__SPIN_LOCK_TRY) && defined(HAVE__SPIN_UNLOCK)
64	#define USE_DARWIN_SPINLOCK 1
65	#else
66	#define USE_DARWIN_SPINLOCK 0
67	#endif
68
69	/* Type and initializer for this architecture.
70	*/
71	#if USE_DARWIN_SPINLOCK
72	typedef volatile long peak_spinlock_t;
73	#define PEAK_SPINLOCK_INITIALIZER (0)
74	#elif defined(__GNUC__)
75	typedef struct { volatile unsigned long lock; } peak_spinlock_t;
76	#define PEAK_SPINLOCK_INITIALIZER ((peak_spinlock_t){ (0) })
77	#elif defined(_AIX)
78	typedef int peak_spinlock_t; /* AIX: typedef int atomic_p; /
79	#define PEAK_SPINLOCK_INITIALIZER (0)
80	#endif
81
82	#if USE_DARWIN_SPINLOCK
83	extern void _spin_lock(peak_spinlock_t *lockp);
84	extern int _spin_lock_try(peak_spinlock_t *lockp);
85	extern void _spin_unlock(peak_spinlock_t *lockp);
86	#endif
87
88	static inline void
89	_peak_spinlock_lock(peak_spinlock_t *lockp)
90	{
91	#if USE_DARWIN_SPINLOCK
92
93	if (!_peak_is_threaded) /* set only if peak uses several threads */
94	return;
95
96	_spin_lock(lockp); /* Lucky, we have a system function for that.
97	* I checked on Darwin 7.0 and it deals properly
98	* with 32 or 64 bit, UP (always depress) or
99	* MP (1000 spin tries before relinquish).
100	* On Darwin 6.x, however, the kernel use generic
101	* PPC MP code, but well. --mbuna
102	*/
103
104	#elif defined(__GNUC__)
105
106	unsigned long tmp;
107
108	if (!_peak_is_threaded) /* set only if peak uses several threads */
109	return;
110
111	__asm__ __volatile__(
112	"b 1f # spin_lock\n\
113	2: lwzx %0,0,%1\n\
114	cmpwi 0,%0,0\n\
115	bne+ 2b\n\
116	1: lwarx %0,0,%1\n\
117	cmpwi 0,%0,0\n\
118	bne- 2b\n"
119	PPC405_ERR77(0,%1)
120	" stwcx. %2,0,%1\n\
121	bne- 2b\n\
122	isync"
123	: "=&r"(tmp)
124	: "r"(&lockp->lock), "r"(1)
125	: "cr0", "memory");
126
127	#elif defined(_AIX)
128
129	unsigned int tries = PEAK_SPINLOCK_ITERATIONS;
130
131	if (!_peak_is_threaded) /* set only if peak uses several threads */
132	return;
133
134	while (!_check_lock(lockp, 0, 1))
135	{
136	if (--tries > 0)
137	{
138	sched_yield();
139	tries = PEAK_SPINLOCK_ITERATIONS;
140	}
141	}
142
143	#else
144	#error _peak_spinlock_lock not supported
145	#endif /* USE_DARWIN_SPINLOCK */
146	}
147
148	static inline int
149	_peak_spinlock_lock_try(peak_spinlock_t *lockp)
150	{
151	#if USE_DARWIN_SPINLOCK
152	if (!_peak_is_threaded) /* set only if peak uses several threads */
153	return 1; /* always succeed */
154
155	return _spin_lock_try(lockp);
156	#elif defined(__GNUC__)
157	unsigned int old, t;
158	unsigned int mask = 1;
159	volatile unsigned int p = ((volatile unsigned int )lockp->lock);
160
161	if (!_peak_is_threaded) /* set only if peak uses several threads */
162	return 1; /* always succeed */
163
164	__asm__ __volatile__(SMP_WMB "\n\
165	1: lwarx %0,0,%4 \n\
166	or %1,%0,%3 \n"
167	PPC405_ERR77(0,%4)
168	" stwcx. %1,0,%4 \n\
169	bne 1b"
170	SMP_MB
171	: "=&r" (old), "=&r" (t), "=m" (*p)
172	: "r" (mask), "r" (p), "m" (*p)
173	: "cc", "memory");
174
175	return (old & mask) == 0;
176	#elif defined(_AIX)
177	return !_check_lock(lockp, 0, 1);
178	#else
179	#error _peak_spinlock_lock_try not supported
180	#endif
181	}
182
183	static inline void
184	_peak_spinlock_unlock(peak_spinlock_t *lockp)
185	{
186	if (!_peak_is_threaded) /* set only if peak uses several threads */
187	return;
188
189	#if USE_DARWIN_SPINLOCK
190	if (!_peak_is_threaded) /* set only if peak uses several threads */
191	return;
192
193	_spin_unlock(lockp);
194
195	#elif defined(__GNUC__)
196	/* The eieio instruction is a faster sync: a barrier providing an ordering
197	* (separately) for (a) cacheable stores and (b) loads and stores to
198	* non-cacheable memory (e.g. I/O devices).
199	*/
200	__asm__ __volatile__("eieio # spin_unlock": : :"memory");
201	lockp->lock = 0;
202	#elif defined(_AIX)
203	_clear_lock(lockp, 0);
204	#else
205	#error _peak_spinlock_unlock not supported
206	#endif
207	}
208
209	#if defined(__cplusplus)
210	}
211	#endif
212
213	#endif /* INCLUDED_PEAK_SPINLOCK_H_ */