1997-09-18 16:21:02 +02:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
|
|
|
* s_lock.h--
|
|
|
|
* This file contains the implementation (if any) for spinlocks.
|
|
|
|
*
|
|
|
|
* Copyright (c) 1994, Regents of the University of California
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* IDENTIFICATION
|
1998-09-18 07:36:24 +02:00
|
|
|
* $Header: /cvsroot/pgsql/src/include/storage/s_lock.h,v 1.48 1998/09/18 05:36:24 momjian Exp $
|
1997-09-18 16:21:02 +02:00
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
1998-06-16 09:18:16 +02:00
|
|
|
|
1997-09-18 16:21:02 +02:00
|
|
|
/*
|
|
|
|
* DESCRIPTION
|
1998-06-16 09:18:16 +02:00
|
|
|
* The public macros that must be provided are:
|
1998-04-29 14:41:29 +02:00
|
|
|
*
|
1998-05-04 18:58:59 +02:00
|
|
|
* void S_INIT_LOCK(slock_t *lock)
|
1998-04-29 14:41:29 +02:00
|
|
|
*
|
|
|
|
* void S_LOCK(slock_t *lock)
|
|
|
|
*
|
1998-05-04 18:58:59 +02:00
|
|
|
* void S_UNLOCK(slock_t *lock)
|
1998-04-29 14:41:29 +02:00
|
|
|
*
|
1998-05-04 18:58:59 +02:00
|
|
|
* void S_LOCK_FREE(slock_t *lock)
|
|
|
|
* Tests if the lock is free. Returns non-zero if free, 0 if locked.
|
1998-04-29 14:41:29 +02:00
|
|
|
*
|
1998-05-04 18:58:59 +02:00
|
|
|
* The S_LOCK() macro implements a primitive but still useful random
|
|
|
|
* backoff to avoid hordes of busywaiting lockers chewing CPU.
|
1997-09-18 16:21:02 +02:00
|
|
|
*
|
1998-05-04 18:58:59 +02:00
|
|
|
* Effectively:
|
1997-09-18 16:21:02 +02:00
|
|
|
* void
|
1998-04-29 14:41:29 +02:00
|
|
|
* S_LOCK(slock_t *lock)
|
1997-09-18 16:21:02 +02:00
|
|
|
* {
|
1998-05-04 18:58:59 +02:00
|
|
|
* while (TAS(lock))
|
|
|
|
* {
|
1998-04-29 14:41:29 +02:00
|
|
|
* // back off the cpu for a semi-random short time
|
1998-05-04 18:58:59 +02:00
|
|
|
* }
|
1997-09-18 16:21:02 +02:00
|
|
|
* }
|
|
|
|
*
|
1998-05-04 18:58:59 +02:00
|
|
|
* This implementation takes advantage of a tas function written
|
|
|
|
* (in assembly language) on machines that have a native test-and-set
|
|
|
|
* instruction. Alternative mutex implementations may also be used.
|
1998-04-29 14:41:29 +02:00
|
|
|
* This function is hidden under the TAS macro to allow substitutions.
|
1997-09-18 16:21:02 +02:00
|
|
|
*
|
1998-04-29 14:41:29 +02:00
|
|
|
* #define TAS(lock) tas(lock)
|
|
|
|
* int tas(slock_t *lock) // True if lock already set
|
|
|
|
*
|
1998-06-16 09:18:16 +02:00
|
|
|
* There are default implementations for all these macros at the bottom
|
|
|
|
* of this file. Check if your platform can use these or needs to
|
|
|
|
* override them.
|
|
|
|
*
|
|
|
|
* NOTES
|
1998-04-29 14:41:29 +02:00
|
|
|
* If none of this can be done, POSTGRES will default to using
|
|
|
|
* System V semaphores (and take a large performance hit -- around 40%
|
|
|
|
* of its time on a DS5000/240 is spent in semop(3)...).
|
|
|
|
*
|
1997-09-18 16:21:02 +02:00
|
|
|
* AIX has a test-and-set but the recommended interface is the cs(3)
|
|
|
|
* system call. This provides an 8-instruction (plus system call
|
|
|
|
* overhead) uninterruptible compare-and-set operation. True
|
|
|
|
* spinlocks might be faster but using cs(3) still speeds up the
|
|
|
|
* regression test suite by about 25%. I don't have an assembler
|
|
|
|
* manual for POWER in any case.
|
|
|
|
*
|
|
|
|
*/
|
1998-05-04 18:58:59 +02:00
|
|
|
#if !defined(S_LOCK_H)
|
1997-09-18 16:21:02 +02:00
|
|
|
#define S_LOCK_H
|
|
|
|
|
|
|
|
#include "storage/ipc.h"
|
|
|
|
|
|
|
|
#if defined(HAS_TEST_AND_SET)
|
|
|
|
|
1998-06-16 09:18:16 +02:00
|
|
|
|
|
|
|
#if defined(__GNUC__)
|
|
|
|
/*************************************************************************
|
|
|
|
* All the gcc inlines
|
1998-04-29 14:41:29 +02:00
|
|
|
*/
|
|
|
|
|
1998-05-05 01:49:17 +02:00
|
|
|
#if defined(__alpha)
|
1998-06-16 09:18:16 +02:00
|
|
|
#define TAS(lock) tas(lock)
|
1998-04-29 14:41:29 +02:00
|
|
|
#define S_UNLOCK(lock) { __asm__("mb"); *(lock) = 0; }
|
|
|
|
|
1998-06-16 09:18:16 +02:00
|
|
|
static __inline__ int
|
|
|
|
tas(volatile slock_t *lock)
|
|
|
|
{
|
1998-09-01 06:40:42 +02:00
|
|
|
register slock_t _res;
|
1998-06-16 09:18:16 +02:00
|
|
|
|
1998-09-01 06:40:42 +02:00
|
|
|
__asm__(" ldq $0, %0 \n\
|
1998-06-16 09:18:16 +02:00
|
|
|
bne $0, already_set \n\
|
|
|
|
ldq_l $0, %0 \n\
|
|
|
|
bne $0, already_set \n\
|
|
|
|
or $31, 1, $0 \n\
|
|
|
|
stq_c $0, %0 \n\
|
|
|
|
beq $0, stqc_fail \n\
|
|
|
|
success: bis $31, $31, %1 \n\
|
|
|
|
mb \n\
|
|
|
|
jmp $31, end \n\
|
|
|
|
stqc_fail: or $31, 1, $0 \n\
|
|
|
|
already_set: bis $0, $0, %1 \n\
|
1998-09-01 06:40:42 +02:00
|
|
|
end: nop ": "=m"(*lock), "=r"(_res): :"0");
|
1998-06-16 09:18:16 +02:00
|
|
|
|
|
|
|
return (int) _res;
|
|
|
|
}
|
1998-09-01 06:40:42 +02:00
|
|
|
|
|
|
|
#endif /* __alpha */
|
1998-04-29 14:41:29 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
1998-06-16 09:18:16 +02:00
|
|
|
#if defined(i386)
|
|
|
|
#define TAS(lock) tas(lock)
|
|
|
|
|
|
|
|
static __inline__ int
|
|
|
|
tas(volatile slock_t *lock)
|
|
|
|
{
|
1998-09-01 06:40:42 +02:00
|
|
|
register slock_t _res = 1;
|
1998-06-16 09:18:16 +02:00
|
|
|
|
1998-09-01 06:40:42 +02:00
|
|
|
__asm__("lock; xchgb %0,%1": "=q"(_res), "=m"(*lock):"0"(_res));
|
1998-06-16 09:18:16 +02:00
|
|
|
return (int) _res;
|
|
|
|
}
|
1998-09-01 06:40:42 +02:00
|
|
|
|
|
|
|
#endif /* i386 */
|
1998-06-16 09:18:16 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#if defined(sparc)
|
|
|
|
#define TAS(lock) tas(lock)
|
|
|
|
|
|
|
|
static __inline__ int
|
|
|
|
tas(volatile slock_t *lock)
|
|
|
|
{
|
1998-09-01 06:40:42 +02:00
|
|
|
register slock_t _res = 1;
|
1998-06-16 09:18:16 +02:00
|
|
|
|
1998-09-01 06:40:42 +02:00
|
|
|
__asm__("ldstub [%2], %0" \
|
|
|
|
: "=r"(_res), "=m"(*lock) \
|
|
|
|
: "r"(lock));
|
1998-06-16 09:18:16 +02:00
|
|
|
return (int) _res;
|
|
|
|
}
|
1998-09-01 06:40:42 +02:00
|
|
|
|
|
|
|
#endif /* sparc */
|
1998-06-16 09:18:16 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#if defined(NEED_VAX_TAS_ASM)
|
|
|
|
/*
|
|
|
|
* VAXen -- even multiprocessor ones
|
|
|
|
* (thanks to Tom Ivar Helbekkmo)
|
|
|
|
*/
|
|
|
|
#define TAS(lock) tas(lock)
|
|
|
|
|
|
|
|
typedef unsigned char slock_t;
|
|
|
|
|
|
|
|
static __inline__ int
|
|
|
|
tas(volatile slock_t *lock)
|
|
|
|
{
|
|
|
|
register _res;
|
|
|
|
|
1998-09-01 06:40:42 +02:00
|
|
|
__asm__(" movl $1, r0 \
|
|
|
|
bbssi $0, (%1), 1 f \
|
|
|
|
clrl r0 \
|
|
|
|
1: movl r0, %0 "
|
|
|
|
: "=r"(_res) /* return value, in register */
|
|
|
|
: "r"(lock) /* argument, 'lock pointer', in register */
|
|
|
|
: "r0"); /* inline code uses this register */
|
1998-06-16 09:18:16 +02:00
|
|
|
return (int) _res;
|
|
|
|
}
|
1998-09-01 06:40:42 +02:00
|
|
|
|
|
|
|
#endif /* NEED_VAX_TAS_ASM */
|
1998-06-16 09:18:16 +02:00
|
|
|
|
|
|
|
|
1998-04-29 14:41:29 +02:00
|
|
|
|
1998-06-16 09:18:16 +02:00
|
|
|
|
1998-09-01 06:40:42 +02:00
|
|
|
#else /* __GNUC__ */
|
1998-04-29 14:41:29 +02:00
|
|
|
/***************************************************************************
|
1998-06-16 09:18:16 +02:00
|
|
|
* All non gcc
|
1998-04-29 14:41:29 +02:00
|
|
|
*/
|
|
|
|
|
1998-05-07 01:25:19 +02:00
|
|
|
#if defined(__alpha)
|
1997-09-18 16:21:02 +02:00
|
|
|
/*
|
|
|
|
* OSF/1 (Alpha AXP)
|
|
|
|
*
|
|
|
|
* Note that slock_t on the Alpha AXP is msemaphore instead of char
|
|
|
|
* (see storage/ipc.h).
|
|
|
|
*/
|
1998-05-04 18:58:59 +02:00
|
|
|
#define TAS(lock) (msem_lock((lock), MSEM_IF_NOWAIT) < 0)
|
1998-02-26 05:46:47 +01:00
|
|
|
#define S_UNLOCK(lock) msem_unlock((lock), 0)
|
|
|
|
#define S_INIT_LOCK(lock) msem_init((lock), MSEM_UNLOCKED)
|
|
|
|
#define S_LOCK_FREE(lock) (!(lock)->msem_state)
|
1998-09-01 06:40:42 +02:00
|
|
|
#endif /* __alpha */
|
1997-09-18 16:21:02 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
1998-06-16 09:18:16 +02:00
|
|
|
#if defined(NEED_I386_TAS_ASM)
|
|
|
|
/* non gcc i386 based things */
|
1997-09-18 16:21:02 +02:00
|
|
|
|
1998-08-22 06:24:41 +02:00
|
|
|
#if defined(USE_UNIVEL_CC)
|
1998-06-16 09:18:16 +02:00
|
|
|
#define TAS(lock) tas(lock)
|
1997-09-18 16:21:02 +02:00
|
|
|
|
1998-09-01 06:40:42 +02:00
|
|
|
asm int
|
1998-06-16 09:18:16 +02:00
|
|
|
tas(slock_t *s_lock)
|
|
|
|
{
|
1998-09-11 18:56:24 +02:00
|
|
|
/* UNIVEL wants %mem in column 1, so we don't pg_indent this file */
|
|
|
|
%mem s_lock
|
|
|
|
pushl %ebx
|
1998-09-01 06:40:42 +02:00
|
|
|
movl s_lock, %ebx
|
|
|
|
movl $255, %eax
|
1998-06-16 09:18:16 +02:00
|
|
|
lock
|
1998-09-11 18:56:24 +02:00
|
|
|
xchgb %al, (%ebx)
|
|
|
|
popl %ebx
|
1998-06-16 09:18:16 +02:00
|
|
|
}
|
1998-07-19 06:17:13 +02:00
|
|
|
|
1998-09-01 06:40:42 +02:00
|
|
|
#endif /* USE_UNIVEL_CC */
|
1997-09-18 16:21:02 +02:00
|
|
|
|
1998-09-01 06:40:42 +02:00
|
|
|
#endif /* NEED_I386_TAS_ASM */
|
1997-09-18 16:21:02 +02:00
|
|
|
|
1998-02-13 06:10:06 +01:00
|
|
|
|
1998-09-18 07:36:24 +02:00
|
|
|
/* NS32K code is in s_lock.c */
|
1998-07-19 03:19:54 +02:00
|
|
|
|
1998-09-01 06:40:42 +02:00
|
|
|
#endif /* defined(__GNUC__) */
|
1998-07-18 16:58:58 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*************************************************************************
|
|
|
|
* These are the platforms that have common code for gcc and non-gcc
|
|
|
|
*/
|
1998-02-13 06:10:06 +01:00
|
|
|
|
1998-07-18 16:51:10 +02:00
|
|
|
#if defined(__hpux)
|
|
|
|
/*
|
|
|
|
* HP-UX (PA-RISC)
|
|
|
|
*
|
|
|
|
* Note that slock_t on PA-RISC is a structure instead of char
|
|
|
|
* (see storage/ipc.h).
|
|
|
|
*
|
|
|
|
* a "set" slock_t has a single word cleared. a "clear" slock_t has
|
|
|
|
* all words set to non-zero. tas() in tas.s
|
|
|
|
*/
|
|
|
|
static const slock_t clear_lock =
|
|
|
|
{{-1, -1, -1, -1}};
|
1998-02-13 06:10:06 +01:00
|
|
|
|
1998-07-18 16:51:10 +02:00
|
|
|
#define S_UNLOCK(lock) (*(lock) = clear_lock) /* struct assignment */
|
|
|
|
#define S_LOCK_FREE(lock) ( *(int *) (((long) (lock) + 15) & ~15) != 0)
|
1998-09-01 06:40:42 +02:00
|
|
|
#endif /* __hpux */
|
1998-02-13 06:10:06 +01:00
|
|
|
|
1997-09-18 16:21:02 +02:00
|
|
|
|
1998-07-18 16:58:58 +02:00
|
|
|
#if defined(__sgi)
|
|
|
|
/*
|
|
|
|
* SGI IRIX 5
|
|
|
|
* slock_t is defined as a struct abilock_t, which has a single unsigned long
|
|
|
|
* member.
|
|
|
|
*
|
|
|
|
* This stuff may be supplemented in the future with Masato Kataoka's MIPS-II
|
|
|
|
* assembly from his NECEWS SVR4 port, but we probably ought to retain this
|
|
|
|
* for the R3000 chips out there.
|
|
|
|
*/
|
1998-09-12 18:07:53 +02:00
|
|
|
#include <mutex.h>
|
|
|
|
#define TAS(lock) (test_and_set(lock,1))
|
|
|
|
#define S_UNLOCK(lock) (test_then_and(lock,0))
|
|
|
|
#define S_INIT_LOCK(lock) (test_then_and(lock,0))
|
|
|
|
#define S_LOCK_FREE(lock) (test_then_add(lock,0) == 0)
|
1998-09-01 06:40:42 +02:00
|
|
|
#endif /* __sgi */
|
1998-07-18 16:58:58 +02:00
|
|
|
|
|
|
|
|
|
|
|
#if defined(_AIX)
|
|
|
|
/*
|
|
|
|
* AIX (POWER)
|
|
|
|
*
|
|
|
|
* Note that slock_t on POWER/POWER2/PowerPC is int instead of char
|
|
|
|
* (see storage/ipc.h).
|
|
|
|
*/
|
|
|
|
#define TAS(lock) cs((int *) (lock), 0, 1)
|
1998-09-01 06:40:42 +02:00
|
|
|
#endif /* _AIX */
|
1998-07-18 16:58:58 +02:00
|
|
|
|
|
|
|
|
|
|
|
#if defined (nextstep)
|
|
|
|
/*
|
|
|
|
* NEXTSTEP (mach)
|
|
|
|
* slock_t is defined as a struct mutex.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define S_LOCK(lock) mutex_lock(lock)
|
|
|
|
#define S_UNLOCK(lock) mutex_unlock(lock)
|
|
|
|
#define S_INIT_LOCK(lock) mutex_init(lock)
|
|
|
|
/* For Mach, we have to delve inside the entrails of `struct mutex'. Ick! */
|
|
|
|
#define S_LOCK_FREE(alock) ((alock)->lock == 0)
|
1998-09-01 06:40:42 +02:00
|
|
|
#endif /* nextstep */
|
1998-07-18 16:58:58 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
1998-06-16 09:18:16 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Default Definitions - override these above as needed.
|
|
|
|
*/
|
1997-09-18 16:21:02 +02:00
|
|
|
|
1998-06-16 09:18:16 +02:00
|
|
|
#if !defined(S_LOCK)
|
|
|
|
extern void s_lock(volatile slock_t *lock, const char *file, const int line);
|
1998-09-01 06:40:42 +02:00
|
|
|
|
1998-06-15 20:40:05 +02:00
|
|
|
#define S_LOCK(lock) \
|
1998-09-01 06:40:42 +02:00
|
|
|
if (TAS((volatile slock_t *) lock)) {\
|
|
|
|
s_lock((volatile slock_t *) lock, __FILE__, __LINE__); \
|
|
|
|
} else
|
|
|
|
#endif /* S_LOCK */
|
1997-09-18 16:21:02 +02:00
|
|
|
|
1998-05-04 18:58:59 +02:00
|
|
|
#if !defined(S_LOCK_FREE)
|
1998-06-16 09:18:16 +02:00
|
|
|
#define S_LOCK_FREE(lock) (*(lock) == 0)
|
1998-09-01 06:40:42 +02:00
|
|
|
#endif /* S_LOCK_FREE */
|
1997-12-30 05:01:28 +01:00
|
|
|
|
1998-05-04 18:58:59 +02:00
|
|
|
#if !defined(S_UNLOCK)
|
|
|
|
#define S_UNLOCK(lock) (*(lock) = 0)
|
1998-09-01 06:40:42 +02:00
|
|
|
#endif /* S_UNLOCK */
|
1997-09-18 16:21:02 +02:00
|
|
|
|
1998-05-04 18:58:59 +02:00
|
|
|
#if !defined(S_INIT_LOCK)
|
1998-02-26 05:46:47 +01:00
|
|
|
#define S_INIT_LOCK(lock) S_UNLOCK(lock)
|
1998-09-01 06:40:42 +02:00
|
|
|
#endif /* S_INIT_LOCK */
|
1997-09-18 16:21:02 +02:00
|
|
|
|
1998-05-04 18:58:59 +02:00
|
|
|
#if !defined(TAS)
|
1998-09-01 06:40:42 +02:00
|
|
|
int tas(volatile slock_t *lock); /* port/.../tas.s, or
|
|
|
|
* s_lock.c */
|
1997-09-25 01:37:26 +02:00
|
|
|
|
1998-09-01 06:40:42 +02:00
|
|
|
#define TAS(lock) tas((volatile slock_t *) lock)
|
|
|
|
#endif /* TAS */
|
1998-06-16 09:18:16 +02:00
|
|
|
|
1998-09-01 06:40:42 +02:00
|
|
|
#endif /* HAS_TEST_AND_SET */
|
|
|
|
#endif /* S_LOCK_H */
|