1 /*-------------------------------------------------------------------------
4 * This file contains the implementation (if any) for spinlocks.
6 * Copyright (c) 1994, Regents of the University of California
10 * $Header: /cvsroot/pgsql/src/include/storage/s_lock.h,v 1.64 1999/07/15 23:04:13 momjian Exp $
12 *-------------------------------------------------------------------------
17 * The public macros that must be provided are:
19 * void S_INIT_LOCK(slock_t *lock)
21 * void S_LOCK(slock_t *lock)
23 * void S_UNLOCK(slock_t *lock)
25 * void S_LOCK_FREE(slock_t *lock)
26 * Tests if the lock is free. Returns non-zero if free, 0 if locked.
28 * The S_LOCK() macro implements a primitive but still useful random
29 * backoff to avoid hordes of busywaiting lockers chewing CPU.
33 * S_LOCK(slock_t *lock)
37 * // back off the cpu for a semi-random short time
41 * This implementation takes advantage of a tas function written
42 * (in assembly language) on machines that have a native test-and-set
43 * instruction. Alternative mutex implementations may also be used.
44 * This function is hidden under the TAS macro to allow substitutions.
46 * #define TAS(lock) tas(lock)
47 * int tas(slock_t *lock) // True if lock already set
49 * There are default implementations for all these macros at the bottom
50 * of this file. Check if your platform can use these or needs to
54 * If none of this can be done, POSTGRES will default to using
55 * System V semaphores (and take a large performance hit -- around 40%
56 * of its time on a DS5000/240 is spent in semop(3)...).
58 * AIX has a test-and-set but the recommended interface is the cs(3)
59 * system call. This provides an 8-instruction (plus system call
60 * overhead) uninterruptible compare-and-set operation. True
61 * spinlocks might be faster but using cs(3) still speeds up the
62 * regression test suite by about 25%. I don't have an assembler
63 * manual for POWER in any case.
66 #if !defined(S_LOCK_H)
69 #include "storage/ipc.h"
71 extern void s_lock_sleep(unsigned spin);
73 #if defined(HAS_TEST_AND_SET)
77 /*************************************************************************
81 #if defined(__alpha__)
82 #define TAS(lock) tas(lock)
83 #define S_UNLOCK(lock) { __asm__("mb"); *(lock) = 0; }
86 tas(volatile slock_t *lock)
88 register slock_t _res;
90 __asm__(" ldq $0, %0 \n\
101 3: bis $0, $0, %1 \n\
102 4: nop ": "=m"(*lock), "=r"(_res): :"0");
107 #endif /* __alpha__ */
111 #if defined(__i386__)
112 #define TAS(lock) tas(lock)
114 static __inline__ int
115 tas(volatile slock_t *lock)
117 register slock_t _res = 1;
119 __asm__("lock; xchgb %0,%1": "=q"(_res), "=m"(*lock):"0"(_res));
123 #endif /* __i386__ */
127 #if defined(__arm32__)
128 #define TAS(lock) tas(lock)
130 static __inline__ int
131 tas(volatile slock_t *lock)
133 register slock_t _res = 1;
135 __asm__("swpb %0, %0, [%3]": "=r"(_res), "=m"(*lock):"0"(_res), "r" (lock));
139 #endif /* __arm32__ */
143 #if defined(__sparc__)
144 #define TAS(lock) tas(lock)
146 static __inline__ int
147 tas(volatile slock_t *lock)
149 register slock_t _res = 1;
151 __asm__("ldstub [%2], %0" \
152 : "=r"(_res), "=m"(*lock) \
157 #endif /* __sparc__ */
160 #if defined(__mc68000__) && defined(__linux__)
161 #define TAS(lock) tas(lock)
163 static __inline__ int
164 tas(volatile slock_t *lock)
168 __asm__ __volatile__ (
170 : "=d" (rv), "=m"(*lock)
176 #endif /* defined(__mc68000__) && defined(__linux__) */
179 #if defined(NEED_VAX_TAS_ASM)
181 * VAXen -- even multiprocessor ones
182 * (thanks to Tom Ivar Helbekkmo)
184 #define TAS(lock) tas(lock)
186 typedef unsigned char slock_t;
188 static __inline__ int
189 tas(volatile slock_t *lock)
193 __asm__(" movl $1, r0 \
194 bbssi $0, (%1), 1 f \
197 : "=r"(_res) /* return value, in register */
198 : "r"(lock) /* argument, 'lock pointer', in register */
199 : "r0"); /* inline code uses this register */
203 #endif /* NEED_VAX_TAS_ASM */
207 #if defined(NEED_NS32K_TAS_ASM)
208 #define TAS(lock) tas(lock)
210 static __inline__ int
211 tas(volatile slock_t *lock)
214 __asm__("sbitb 0, %0 \n\
216 : "=m"(*lock), "=r"(_res));
220 #endif /* NEED_NS32K_TAS_ASM */
225 /***************************************************************************
229 #if defined(__alpha__)
233 * Note that slock_t on the Alpha AXP is msemaphore instead of char
234 * (see storage/ipc.h).
236 #define TAS(lock) (msem_lock((lock), MSEM_IF_NOWAIT) < 0)
237 #define S_UNLOCK(lock) msem_unlock((lock), 0)
238 #define S_INIT_LOCK(lock) msem_init((lock), MSEM_UNLOCKED)
239 #define S_LOCK_FREE(lock) (!(lock)->msem_state)
240 #endif /* __alpha__ */
244 #if defined(NEED_I386_TAS_ASM)
245 /* non gcc i386 based things */
247 #if defined(USE_UNIVEL_CC)
248 #define TAS(lock) tas(lock)
253 /* UNIVEL wants %mem in column 1, so we don't pg_indent this file */
263 #endif /* USE_UNIVEL_CC */
265 #endif /* NEED_I386_TAS_ASM */
267 #endif /* defined(__GNUC__) */
271 /*************************************************************************
272 * These are the platforms that have common code for gcc and non-gcc
279 * Note that slock_t on PA-RISC is a structure instead of char
280 * (see include/port/hpux.h).
282 * a "set" slock_t has a single word cleared. a "clear" slock_t has
283 * all words set to non-zero. tas() in tas.s
286 #define S_UNLOCK(lock) \
288 volatile slock_t *lock_ = (volatile slock_t *) (lock); \
289 lock_->sema[0] = lock_->sema[1] = lock_->sema[2] = lock_->sema[3] = -1; \
292 #define S_LOCK_FREE(lock) ( *(int *) (((long) (lock) + 15) & ~15) != 0)
300 * slock_t is defined as a unsigned long. We use the standard SGI
303 * The following comment is left for historical reasons, but is probably
304 * not a good idea since the mutex ABI is supported.
306 * This stuff may be supplemented in the future with Masato Kataoka's MIPS-II
307 * assembly from his NECEWS SVR4 port, but we probably ought to retain this
308 * for the R3000 chips out there.
311 #define TAS(lock) (test_and_set(lock,1))
312 #define S_UNLOCK(lock) (test_then_and(lock,0))
313 #define S_INIT_LOCK(lock) (test_then_and(lock,0))
314 #define S_LOCK_FREE(lock) (test_then_add(lock,0) == 0)
319 * SINIX / Reliant UNIX
320 * slock_t is defined as a struct abilock_t, which has a single unsigned long
321 * member. (Basically same as SGI)
324 #define TAS(lock) (!acquire_lock(lock))
325 #define S_UNLOCK(lock) release_lock(lock)
326 #define S_INIT_LOCK(lock) init_lock(lock)
327 #define S_LOCK_FREE(lock) (stat_lock(lock) == UNLOCKED)
335 * Note that slock_t on POWER/POWER2/PowerPC is int instead of char
336 * (see storage/ipc.h).
338 #define TAS(lock) cs((int *) (lock), 0, 1)
342 #if defined (nextstep)
345 * slock_t is defined as a struct mutex.
348 #define S_LOCK(lock) mutex_lock(lock)
349 #define S_UNLOCK(lock) mutex_unlock(lock)
350 #define S_INIT_LOCK(lock) mutex_init(lock)
351 /* For Mach, we have to delve inside the entrails of `struct mutex'. Ick! */
352 #define S_LOCK_FREE(alock) ((alock)->lock == 0)
353 #endif /* nextstep */
358 /****************************************************************************
359 * Default Definitions - override these above as needed.
363 extern void s_lock(volatile slock_t *lock, const char *file, const int line);
365 #define S_LOCK(lock) \
367 if (TAS((volatile slock_t *) lock)) \
368 s_lock((volatile slock_t *) lock, __FILE__, __LINE__); \
372 #if !defined(S_LOCK_FREE)
373 #define S_LOCK_FREE(lock) (*(lock) == 0)
374 #endif /* S_LOCK_FREE */
376 #if !defined(S_UNLOCK)
377 #define S_UNLOCK(lock) (*(lock) = 0)
378 #endif /* S_UNLOCK */
380 #if !defined(S_INIT_LOCK)
381 #define S_INIT_LOCK(lock) S_UNLOCK(lock)
382 #endif /* S_INIT_LOCK */
385 int tas(volatile slock_t *lock); /* port/.../tas.s, or
388 #define TAS(lock) tas((volatile slock_t *) lock)
391 #endif /* HAS_TEST_AND_SET */
392 #endif /* S_LOCK_H */