open-dsi
/
postgres
mirror of https://github.com/postgres/postgres
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Here is the long awaited optimized version of the S_LOCK patch.

Browse Source 
This incorporates all the precedeing patches and emailed suggestions
and the results of the performance testing I posted last week. I
would like to get this tested on as many platforms as possible so
I can verify it went in correctly (as opposed to the horrorshow
last time I sent in a patch).

Once this is confirmed, I will make a tarball of files that can be
dropped into a 6.3.2 source tree as a few people have asked for
this in 6.3.2 as well.

David Gould
REL6_4
Bruce Momjian 28 years ago
parent 7784312f99
commit 0d8e7f6381
3 changed files with 187 additions and 244 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 4
      src/backend/storage/buffer/Makefile
  2. 227
      src/backend/storage/buffer/s_lock.c
  3. 194
      src/include/storage/s_lock.h

4
src/backend/storage/buffer/Makefile
Unescape View File

@ -4,7 +4,7 @@
# Makefile for storage/buffer # Makefile for storage/buffer
# #
# IDENTIFICATION # IDENTIFICATION
# $Header: /cvsroot/pgsql/src/backend/storage/buffer/Makefile,v 1.10 1998/05/04 16:58:37 scrappy Exp $ # $Header: /cvsroot/pgsql/src/backend/storage/buffer/Makefile,v 1.11 1998/06/16 07:18:15 momjian Exp $
# #
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
@ -27,7 +27,7 @@ clean:
rm -f SUBSYS.o $(OBJS) s_lock_test rm -f SUBSYS.o $(OBJS) s_lock_test
s_lock_test: s_lock.c s_lock_test: s_lock.c
$(CC) $(CFLAGS) -DS_LOCK_TEST=1 -g s_lock.c -o s_lock_test $(CC) $(CFLAGS) -DS_LOCK_TEST=1 s_lock.c -o s_lock_test
./s_lock_test ./s_lock_test
ifeq (depend,$(wildcard depend)) ifeq (depend,$(wildcard depend))

227
src/backend/storage/buffer/s_lock.c
Unescape View File

@ -7,12 +7,13 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/storage/buffer/Attic/s_lock.c,v 1.7 1998/05/04 23:49:09 scrappy Exp $ * $Header: /cvsroot/pgsql/src/backend/storage/buffer/Attic/s_lock.c,v 1.8 1998/06/16 07:18:15 momjian Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
#include <stdio.h> #include <stdio.h>
#include <sys/time.h>
#include "config.h" #include "config.h"
#include "c.h" #include "c.h"
@ -22,50 +23,24 @@
/* /*
* Each time we busy spin we select the next element of this array as the * Each time we busy spin we select the next element of this array as the
* number of microseconds to wait. This accomplishes pseudo random back-off. * number of microseconds to wait. This accomplishes pseudo random back-off.
* Values are not critical and are weighted to the low end of the range. They * Values are not critical but 10 milliseconds is a common platform
* were chosen to work even with different select() timer resolutions on * granularity.
* different platforms. * note: total time to cycle through all 16 entries might be about .07 sec.
* note: total time to cycle through all 16 entries might be about .1 second.
*/ */
#define S_NSPINCYCLE 20
#define S_MAX_BUSY 500 * S_NSPINCYCLE
int s_spincycle[S_NSPINCYCLE] = int s_spincycle[S_NSPINCYCLE] =
{0, 0, 0, 1000, 5000, 0, 10000, 3000, { 0, 0, 0, 0, 10000, 0, 0, 0, 10000, 0,
0, 10000, 0, 15000, 9000, 21000, 6000, 30000 0, 10000, 0, 0, 10000, 0, 10000, 0, 10000, 10000
}; };
#if defined(S_LOCK_DEBUG)
/*
* s_lock(lock) - take a spinlock
* add intrumentation code to this and define S_LOCK_DEBUG
* instead of hacking up the macro in s_lock.h
*/
void
s_lock(slock_t *lock, char *file, int line)
{
int spins = 0;
while (TAS(lock))
{
struct timeval delay;
delay.tv_sec = 0;
delay.tv_usec = s_spincycle[spins++ % S_NSPINCYCLE];
(void) select(0, NULL, NULL, NULL, &delay);
if (spins > S_MAX_BUSY)
{
/* It's been well over a minute... */
s_lock_stuck(lock, file, line);
}
}
}
#endif /* S_LOCK_DEBUG */
/* /*
* s_lock_stuck(lock) - deal with stuck spinlock * s_lock_stuck(lock) - complain about a stuck spinlock
*/ */
void static void
s_lock_stuck(slock_t *lock, char *file, int line) s_lock_stuck(volatile slock_t *lock, const char *file, const int line)
{ {
fprintf(stderr, fprintf(stderr,
"\nFATAL: s_lock(%08x) at %s:%d, stuck spinlock. Aborting.\n", "\nFATAL: s_lock(%08x) at %s:%d, stuck spinlock. Aborting.\n",
@ -79,84 +54,51 @@ s_lock_stuck(slock_t *lock, char *file, int line)
/* /*
* Various TAS implementations moved from s_lock.h to avoid redundant * s_lock(lock) - take a spinlock with backoff
* definitions of the same routine.
* RESOLVE: move this to tas.c. Alternatively get rid of tas.[cso] and fold
* all that into this file.
*/ */
void
s_lock(volatile slock_t *lock, const char *file, const int line)
#if defined(linux)
/*************************************************************************
* All the Linux flavors
*/
#if defined(__alpha)
int
tas(slock_t *lock)
{ {
slock_t _res; int spins = 0;
__asm__(" ldq $0, %0 \n\
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\
end: nop ": "=m"(*lock), "=r"(_res): :"0");
return (_res != 0);
}
#endif /* __alpha */
#if defined(i386) while (TAS(lock))
int
tas(slock_t *lock)
{ {
slock_t _res = 1; struct timeval delay;
__asm__("lock; xchgb %0,%1": "=q"(_res), "=m"(*lock):"0"(0x1)); delay.tv_sec = 0;
return (_res != 0); delay.tv_usec = s_spincycle[spins % S_NSPINCYCLE];
(void) select(0, NULL, NULL, NULL, &delay);
if (++spins > S_MAX_BUSY)
{
/* It's been over a minute... */
s_lock_stuck(lock, file, line);
}
}
} }
#endif /* i386 */
#if defined(sparc)
int /*
tas(slock_t *lock) * Various TAS implementations that cannot live in s_lock.h as no inline
{ * definition exists (yet).
slock_t _res; * In the future, get rid of tas.[cso] and fold it into this file.
slock_t *tmplock = lock; */
__asm__("ldstub [%1], %0" \
: "=&r"(_res), "=r"(tmplock) \
: "1"(tmplock));
return (_res != 0);
}
#endif /* sparc */ #if defined(__GNUC__)
/*************************************************************************
* All the gcc flavors that are not inlined
*/
#if defined(PPC) #if defined(PPC)
/* Note: need a nice gcc constrained asm version so it can be inlined */
static int int
tas_dummy() tas(volatile slock_t *lock)
{ {
__asm__(" \n\ __asm__("lwarx 5,0,3 \n\
tas: \n\
lwarx 5,0,3 \n\
cmpwi 5,0 \n\ cmpwi 5,0 \n\
bne fail \n\ bne fail \n\
addi 5,5,1 \n\ addi 5,5,1 \n\
@ -169,14 +111,13 @@ success: \n\
blr \n\ blr \n\
"); ");
} }
#endif /* PPC */ #endif /* PPC */
#else /* defined(linux) */ #else /* defined(__GNUC__) */
/*************************************************************************** /***************************************************************************
* All Non-Linux * All non gcc
*/ */
@ -208,26 +149,18 @@ tas_dummy() /* really means: extern int tas(slock_t *lock); */
#if defined(NEED_SPARC_TAS_ASM) #if defined(NEED_SPARC_TAS_ASM)
/* /*
* bsd and bsdi sparc machines * sparc machines not using gcc
*/ */
/* if we're using -ansi w/ gcc, use __asm__ instead of asm */
#if defined(__STRICT_ANSI__)
#define asm(x) __asm__(x)
#endif /* __STRICT_ANSI__ */
static void static void
tas_dummy() /* really means: extern int tas(slock_t *lock); */ tas_dummy() /* really means: extern int tas(slock_t *lock); */
{ {
asm(".seg \"data\""); asm(".seg \"data\"");
asm(".seg \"text\""); asm(".seg \"text\"");
asm("_tas:"); asm("_tas:");
/* /*
* Sparc atomic test and set (sparc calls it "atomic load-store") * Sparc atomic test and set (sparc calls it "atomic load-store")
*/ */
asm("ldstub [%r8], %r8"); asm("ldstub [%r8], %r8");
asm("retl"); asm("retl");
asm("nop"); asm("nop");
} }
@ -237,76 +170,25 @@ tas_dummy() /* really means: extern int tas(slock_t *lock); */
#if defined(NEED_VAX_TAS_ASM)
/*
* VAXen -- even multiprocessor ones
* (thanks to Tom Ivar Helbekkmo)
*/
typedef unsigned char slock_t;
int
tas(slock_t *lock)
{
register ret;
asm(" movl $1, r0
bbssi $0, (%1), 1f
clrl r0
1: movl r0, %0 "
: "=r"(ret) /* return value, in register */
: "r"(lock) /* argument, 'lock pointer', in register */
: "r0"); /* inline code uses this register */
return ret;
}
#endif /* NEED_VAX_TAS_ASM */
#if defined(NEED_I386_TAS_ASM) #if defined(NEED_I386_TAS_ASM)
/* /* non gcc i386 based things */
* i386 based things #endif /* NEED_I386_TAS_ASM */
*/
#if defined(USE_UNIVEL_CC)
asm int
tas(slock_t *s_lock)
{
%lab locked;
/* Upon entry, %eax will contain the pointer to the lock byte */
pushl % ebx
xchgl % eax, %ebx
xor % eax, %eax
movb $255, %al
lock
xchgb % al, (%ebx)
popl % ebx
}
#else /* USE_UNIVEL_CC */
int
tas(slock_t *lock)
{
slock_t _res = 1;
__asm__("lock; xchgb %0,%1": "=q"(_res), "=m"(*lock):"0"(0x1));
return (_res != 0);
}
#endif /* USE_UNIVEL_CC */
#endif /* NEED_I386_TAS_ASM */ #endif /* not __GNUC__ */
#endif /* linux */
/*****************************************************************************/
#if defined(S_LOCK_TEST) #if defined(S_LOCK_TEST)
slock_t test_lock; /*
* test program for verifying a port.
*/
volatile slock_t test_lock;
void void
main() main()
@ -330,7 +212,7 @@ main()
printf("S_LOCK_TEST: this will hang for a few minutes and then abort\n"); printf("S_LOCK_TEST: this will hang for a few minutes and then abort\n");
printf(" with a 'stuck spinlock' message if S_LOCK()\n"); printf(" with a 'stuck spinlock' message if S_LOCK()\n");
printf(" and TAS() are working.\n"); printf(" and TAS() are working.\n");
S_LOCK(&test_lock); s_lock(&test_lock, __FILE__, __LINE__);
printf("S_LOCK_TEST: failed, lock not locked~\n"); printf("S_LOCK_TEST: failed, lock not locked~\n");
exit(3); exit(3);
@ -338,3 +220,4 @@ main()
} }
#endif /* S_LOCK_TEST */ #endif /* S_LOCK_TEST */

194
src/include/storage/s_lock.h
Unescape View File

@ -7,13 +7,14 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/include/storage/s_lock.h,v 1.35 1998/06/15 18:40:04 momjian Exp $ * $Header: /cvsroot/pgsql/src/include/storage/s_lock.h,v 1.36 1998/06/16 07:18:16 momjian Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
/* /*
* DESCRIPTION * DESCRIPTION
* The public functions that must be provided are: * The public macros that must be provided are:
* *
* void S_INIT_LOCK(slock_t *lock) * void S_INIT_LOCK(slock_t *lock)
* *
@ -45,11 +46,15 @@
* #define TAS(lock) tas(lock) * #define TAS(lock) tas(lock)
* int tas(slock_t *lock) // True if lock already set * int tas(slock_t *lock) // True if lock already set
* *
* 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
* If none of this can be done, POSTGRES will default to using * If none of this can be done, POSTGRES will default to using
* System V semaphores (and take a large performance hit -- around 40% * System V semaphores (and take a large performance hit -- around 40%
* of its time on a DS5000/240 is spent in semop(3)...). * of its time on a DS5000/240 is spent in semop(3)...).
* *
* NOTES
* AIX has a test-and-set but the recommended interface is the cs(3) * AIX has a test-and-set but the recommended interface is the cs(3)
* system call. This provides an 8-instruction (plus system call * system call. This provides an 8-instruction (plus system call
* overhead) uninterruptible compare-and-set operation. True * overhead) uninterruptible compare-and-set operation. True
@ -57,10 +62,6 @@
* regression test suite by about 25%. I don't have an assembler * regression test suite by about 25%. I don't have an assembler
* manual for POWER in any case. * manual for POWER in any case.
* *
* 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.
*
*/ */
#if !defined(S_LOCK_H) #if !defined(S_LOCK_H)
#define S_LOCK_H #define S_LOCK_H
@ -69,23 +70,104 @@
#if defined(HAS_TEST_AND_SET) #if defined(HAS_TEST_AND_SET)
#if defined(linux)
/*************************************************************************** #if defined(__GNUC__)
* All Linux /*************************************************************************
* All the gcc inlines
*/ */
#if defined(__alpha) #if defined(__alpha)
#define TAS(lock) tas(lock)
#define S_UNLOCK(lock) { __asm__("mb"); *(lock) = 0; } #define S_UNLOCK(lock) { __asm__("mb"); *(lock) = 0; }
static __inline__ int
tas(volatile slock_t *lock)
{
register slock_t _res;
__asm__(" ldq $0, %0 \n\
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\
end: nop " : "=m"(*lock), "=r"(_res) : : "0");
return (int) _res;
}
#endif /* __alpha */ #endif /* __alpha */
#if defined(i386)
#define TAS(lock) tas(lock)
static __inline__ int
tas(volatile slock_t *lock)
{
register slock_t _res = 1;
__asm__("lock; xchgb %0,%1" : "=q"(_res), "=m"(*lock) : "0"(_res) );
return (int) _res;
}
#endif /* i386 */
#if defined(sparc)
#define TAS(lock) tas(lock)
static __inline__ int
tas(volatile slock_t *lock)
{
register slock_t _res = 1;
__asm__("ldstub [%1], %0" \
: "=r"(_res), "=m"(*lock) \
: "1"(lock));
return (int) _res;
}
#endif /* sparc */
#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;
__asm__(" movl $1, r0
bbssi $0, (%1), 1f
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 */
return (int) _res;
}
#endif /* NEED_VAX_TAS_ASM */
#else /* linux */
#else /* __GNUC__ */
/*************************************************************************** /***************************************************************************
* All non Linux * All non gcc
*/ */
#if defined (nextstep) #if defined (nextstep)
@ -95,14 +177,10 @@
*/ */
#define S_LOCK(lock) mutex_lock(lock) #define S_LOCK(lock) mutex_lock(lock)
#define S_UNLOCK(lock) mutex_unlock(lock) #define S_UNLOCK(lock) mutex_unlock(lock)
#define S_INIT_LOCK(lock) mutex_init(lock) #define S_INIT_LOCK(lock) mutex_init(lock)
/* For Mach, we have to delve inside the entrails of `struct mutex'. Ick! */ /* For Mach, we have to delve inside the entrails of `struct mutex'. Ick! */
#define S_LOCK_FREE(alock) ((alock)->lock == 0) #define S_LOCK_FREE(alock) ((alock)->lock == 0)
#endif /* nextstep */ #endif /* nextstep */
@ -118,13 +196,9 @@
* for the R3000 chips out there. * for the R3000 chips out there.
*/ */
#define TAS(lock) (!acquire_lock(lock)) #define TAS(lock) (!acquire_lock(lock))
#define S_UNLOCK(lock) release_lock(lock) #define S_UNLOCK(lock) release_lock(lock)
#define S_INIT_LOCK(lock) init_lock(lock) #define S_INIT_LOCK(lock) init_lock(lock)
#define S_LOCK_FREE(lock) (stat_lock(lock) == UNLOCKED) #define S_LOCK_FREE(lock) (stat_lock(lock) == UNLOCKED)
#endif /* __sgi */ #endif /* __sgi */
@ -137,13 +211,9 @@
* (see storage/ipc.h). * (see storage/ipc.h).
*/ */
#define TAS(lock) (msem_lock((lock), MSEM_IF_NOWAIT) < 0) #define TAS(lock) (msem_lock((lock), MSEM_IF_NOWAIT) < 0)
#define S_UNLOCK(lock) msem_unlock((lock), 0) #define S_UNLOCK(lock) msem_unlock((lock), 0)
#define S_INIT_LOCK(lock) msem_init((lock), MSEM_UNLOCKED) #define S_INIT_LOCK(lock) msem_init((lock), MSEM_UNLOCKED)
#define S_LOCK_FREE(lock) (!(lock)->msem_state) #define S_LOCK_FREE(lock) (!(lock)->msem_state)
#endif /* __alpha */ #endif /* __alpha */
@ -156,7 +226,6 @@
* (see storage/ipc.h). * (see storage/ipc.h).
*/ */
#define TAS(lock) cs((int *) (lock), 0, 1) #define TAS(lock) cs((int *) (lock), 0, 1)
#endif /* _AIX */ #endif /* _AIX */
@ -175,64 +244,56 @@ static slock_t clear_lock =
{-1, -1, -1, -1}; {-1, -1, -1, -1};
#define S_UNLOCK(lock) (*(lock) = clear_lock) /* struct assignment */ #define S_UNLOCK(lock) (*(lock) = clear_lock) /* struct assignment */
#define S_LOCK_FREE(lock) ( *(int *) (((long) (lock) + 15) & ~15) != 0) #define S_LOCK_FREE(lock) ( *(int *) (((long) (lock) + 15) & ~15) != 0)
#endif /* __hpux */ #endif /* __hpux */
#endif /* else defined(linux) */ #if defined(NEED_I386_TAS_ASM)
/* non gcc i386 based things */
#if defined(USE_UNIVEL_CC)
#define TAS(lock) tas(lock)
/**************************************************************************** asm int
* Default Definitions - override these above as needed. tas(slock_t *s_lock)
*/ {
%lab locked;
/* Upon entry, %eax will contain the pointer to the lock byte */
pushl % ebx
xchgl % eax, %ebx
xor % eax, %eax
movb $255, %al
lock
xchgb % al, (%ebx)
popl % ebx
}
#endif /* USE_UNIVEL_CC */
#if !defined(S_LOCK)
#include <sys/time.h> #endif /* NEED_I386_TAS_ASM */
#define S_NSPINCYCLE 16
#define S_MAX_BUSY 1000 * S_NSPINCYCLE
extern int s_spincycle[]; #endif /* else defined(__GNUC__) */
extern void s_lock_stuck(slock_t *lock, char *file, int line);
#if defined(S_LOCK_DEBUG)
extern void s_lock(slock_t *lock);
#define S_LOCK(lock) s_lock(lock, __FILE__, __LINE__)
#else /* S_LOCK_DEBUG */ /****************************************************************************
* Default Definitions - override these above as needed.
*/
#if !defined(S_LOCK)
extern void s_lock(volatile slock_t *lock, const char *file, const int line);
#define S_LOCK(lock) \ #define S_LOCK(lock) \
do { \ if (TAS((volatile slock_t *) lock)) {\
int spins = 0; \ s_lock((volatile slock_t *) lock, __FILE__, __LINE__); \
while (TAS(lock)) \ } else
{ \
struct timeval delay; \
delay.tv_sec = 0; \
delay.tv_usec = s_spincycle[spins++ % S_NSPINCYCLE]; \
(void) select(0, NULL, NULL, NULL, &delay); \
if (spins > S_MAX_BUSY) \
{ \
/* It's been well over a minute... */ \
s_lock_stuck(lock, __FILE__, __LINE__); \
} \
} \
} while(0)
#endif /* S_LOCK_DEBUG */
#endif /* S_LOCK */ #endif /* S_LOCK */
#if !defined(S_LOCK_FREE) #if !defined(S_LOCK_FREE)
#define S_LOCK_FREE(lock) ((*lock) == 0) #define S_LOCK_FREE(lock) (*(lock) == 0)
#endif /* S_LOCK_FREE */ #endif /* S_LOCK_FREE */
#if !defined(S_UNLOCK) #if !defined(S_UNLOCK)
@ -244,12 +305,11 @@ do { \
#endif /* S_INIT_LOCK */ #endif /* S_INIT_LOCK */
#if !defined(TAS) #if !defined(TAS)
int tas(slock_t *lock); /* port/.../tas.s, or s_lock.c */ int tas(volatile slock_t *lock); /* port/.../tas.s, or s_lock.c */
#define TAS(lock) tas((volatile slock_t *) lock)
#define TAS(lock) tas(lock)
#endif /* TAS */ #endif /* TAS */
#endif /* HAS_TEST_AND_SET */ #endif /* HAS_TEST_AND_SET */
#endif /* S_LOCK_H */ #endif /* S_LOCK_H */

Write Preview
Loading…
Cancel
Save