diff --git a/src/backend/storage/lmgr/proc.c b/src/backend/storage/lmgr/proc.c
index 3b264fa1796bf920b927ff85b050c0b9052a78c6..7e83e5f0cb2186b39536c5efebcf22ee7e420f53 100644
--- a/src/backend/storage/lmgr/proc.c
+++ b/src/backend/storage/lmgr/proc.c
@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/storage/lmgr/proc.c,v 1.164 2005/09/19 17:21:47 momjian Exp $
+ * $PostgreSQL: pgsql/src/backend/storage/lmgr/proc.c,v 1.165 2005/10/11 20:41:32 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -171,6 +171,8 @@ InitProcGlobal(void)
ProcGlobal->freeProcs = INVALID_OFFSET;
+ ProcGlobal->spins_per_delay = DEFAULT_SPINS_PER_DELAY;
+
/*
* Pre-create the PGPROC structures and create a semaphore for
* each.
@@ -225,9 +227,14 @@ InitProcess(void)
/*
* Try to get a proc struct from the free list. If this fails, we
* must be out of PGPROC structures (not to mention semaphores).
+ *
+ * While we are holding the ProcStructLock, also copy the current
+ * shared estimate of spins_per_delay to local storage.
*/
SpinLockAcquire(ProcStructLock);
+ set_spins_per_delay(procglobal->spins_per_delay);
+
myOffset = procglobal->freeProcs;
if (myOffset != INVALID_OFFSET)
@@ -319,21 +326,38 @@ InitDummyProcess(int proctype)
Assert(proctype >= 0 && proctype < NUM_DUMMY_PROCS);
+ /*
+ * Just for paranoia's sake, we use the ProcStructLock to protect
+ * assignment and releasing of DummyProcs entries.
+ *
+ * While we are holding the ProcStructLock, also copy the current
+ * shared estimate of spins_per_delay to local storage.
+ */
+ SpinLockAcquire(ProcStructLock);
+
+ set_spins_per_delay(ProcGlobal->spins_per_delay);
+
dummyproc = &DummyProcs[proctype];
/*
* dummyproc should not presently be in use by anyone else
*/
if (dummyproc->pid != 0)
+ {
+ SpinLockRelease(ProcStructLock);
elog(FATAL, "DummyProc[%d] is in use by PID %d",
proctype, dummyproc->pid);
+ }
MyProc = dummyproc;
+ MyProc->pid = MyProcPid; /* marks dummy proc as in use by me */
+
+ SpinLockRelease(ProcStructLock);
+
/*
* Initialize all fields of MyProc, except MyProc->sem which was set
* up by InitProcGlobal.
*/
- MyProc->pid = MyProcPid; /* marks dummy proc as in use by me */
SHMQueueElemInit(&(MyProc->links));
MyProc->waitStatus = STATUS_OK;
MyProc->xid = InvalidTransactionId;
@@ -510,6 +534,9 @@ ProcKill(int code, Datum arg)
/* PGPROC struct isn't mine anymore */
MyProc = NULL;
+ /* Update shared estimate of spins_per_delay */
+ procglobal->spins_per_delay = update_spins_per_delay(procglobal->spins_per_delay);
+
SpinLockRelease(ProcStructLock);
}
@@ -533,11 +560,18 @@ DummyProcKill(int code, Datum arg)
/* Release any LW locks I am holding (see notes above) */
LWLockReleaseAll();
+ SpinLockAcquire(ProcStructLock);
+
/* Mark dummy proc no longer in use */
MyProc->pid = 0;
/* PGPROC struct isn't mine anymore */
MyProc = NULL;
+
+ /* Update shared estimate of spins_per_delay */
+ ProcGlobal->spins_per_delay = update_spins_per_delay(ProcGlobal->spins_per_delay);
+
+ SpinLockRelease(ProcStructLock);
}
diff --git a/src/backend/storage/lmgr/s_lock.c b/src/backend/storage/lmgr/s_lock.c
index d6c1a6578752964bbf3375a198a6aee50ffab9ed..1fb069d4f373a21a8311d8ccb07111f31bdd8bdd 100644
--- a/src/backend/storage/lmgr/s_lock.c
+++ b/src/backend/storage/lmgr/s_lock.c
@@ -9,7 +9,7 @@
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/storage/lmgr/s_lock.c,v 1.38 2005/08/26 14:47:35 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/storage/lmgr/s_lock.c,v 1.39 2005/10/11 20:41:32 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -21,6 +21,10 @@
#include "storage/s_lock.h"
#include "miscadmin.h"
+
+static int spins_per_delay = DEFAULT_SPINS_PER_DELAY;
+
+
/*
* s_lock_stuck() - complain about a stuck spinlock
*/
@@ -49,54 +53,67 @@ s_lock(volatile slock_t *lock, const char *file, int line)
* We loop tightly for awhile, then delay using pg_usleep() and try
* again. Preferably, "awhile" should be a small multiple of the
* maximum time we expect a spinlock to be held. 100 iterations seems
- * about right. In most multi-CPU scenarios, the spinlock is probably
- * held by a process on another CPU and will be released before we
- * finish 100 iterations. However, on a uniprocessor, the tight loop
- * is just a waste of cycles, so don't iterate thousands of times.
+ * about right as an initial guess. However, on a uniprocessor the
+ * loop is a waste of cycles, while in a multi-CPU scenario it's usually
+ * better to spin a bit longer than to call the kernel, so we try to
+ * adapt the spin loop count depending on whether we seem to be in
+ * a uniprocessor or multiprocessor.
+ *
+ * Note: you might think MIN_SPINS_PER_DELAY should be just 1, but you'd
+ * be wrong; there are platforms where that can result in a "stuck
+ * spinlock" failure. This has been seen particularly on Alphas; it
+ * seems that the first TAS after returning from kernel space will always
+ * fail on that hardware.
*
* Once we do decide to block, we use randomly increasing pg_usleep()
- * delays. The first delay is 10 msec, then the delay randomly
- * increases to about one second, after which we reset to 10 msec and
+ * delays. The first delay is 1 msec, then the delay randomly
+ * increases to about one second, after which we reset to 1 msec and
* start again. The idea here is that in the presence of heavy
* contention we need to increase the delay, else the spinlock holder
* may never get to run and release the lock. (Consider situation
* where spinlock holder has been nice'd down in priority by the
* scheduler --- it will not get scheduled until all would-be
- * acquirers are sleeping, so if we always use a 10-msec sleep, there
+ * acquirers are sleeping, so if we always use a 1-msec sleep, there
* is a real possibility of starvation.) But we can't just clamp the
* delay to an upper bound, else it would take a long time to make a
* reasonable number of tries.
*
* We time out and declare error after NUM_DELAYS delays (thus, exactly
* that many tries). With the given settings, this will usually take
- * 3 or so minutes. It seems better to fix the total number of tries
+ * 2 or so minutes. It seems better to fix the total number of tries
* (and thus the probability of unintended failure) than to fix the
* total time spent.
*
- * The pg_usleep() delays are measured in centiseconds (0.01 sec) because
- * 10 msec is a common resolution limit at the OS level.
+ * The pg_usleep() delays are measured in milliseconds because 1 msec
+ * is a common resolution limit at the OS level for newer platforms.
+ * On older platforms the resolution limit is usually 10 msec, in
+ * which case the total delay before timeout will be a bit more.
*/
-#define SPINS_PER_DELAY 100
+#define MIN_SPINS_PER_DELAY 10
+#define MAX_SPINS_PER_DELAY 1000
#define NUM_DELAYS 1000
-#define MIN_DELAY_CSEC 1
-#define MAX_DELAY_CSEC 100
+#define MIN_DELAY_MSEC 1
+#define MAX_DELAY_MSEC 1000
int spins = 0;
int delays = 0;
- int cur_delay = MIN_DELAY_CSEC;
+ int cur_delay = 0;
while (TAS(lock))
{
/* CPU-specific delay each time through the loop */
SPIN_DELAY();
- /* Block the process every SPINS_PER_DELAY tries */
- if (++spins > SPINS_PER_DELAY)
+ /* Block the process every spins_per_delay tries */
+ if (++spins >= spins_per_delay)
{
if (++delays > NUM_DELAYS)
s_lock_stuck(lock, file, line);
- pg_usleep(cur_delay * 10000L);
+ if (cur_delay == 0) /* first time to delay? */
+ cur_delay = MIN_DELAY_MSEC;
+
+ pg_usleep(cur_delay * 1000L);
#if defined(S_LOCK_TEST)
fprintf(stdout, "*");
@@ -107,14 +124,76 @@ s_lock(volatile slock_t *lock, const char *file, int line)
cur_delay += (int) (cur_delay *
(((double) random()) / ((double) MAX_RANDOM_VALUE)) + 0.5);
/* wrap back to minimum delay when max is exceeded */
- if (cur_delay > MAX_DELAY_CSEC)
- cur_delay = MIN_DELAY_CSEC;
+ if (cur_delay > MAX_DELAY_MSEC)
+ cur_delay = MIN_DELAY_MSEC;
spins = 0;
}
}
+
+ /*
+ * If we were able to acquire the lock without delaying, it's a good
+ * indication we are in a multiprocessor. If we had to delay, it's
+ * a sign (but not a sure thing) that we are in a uniprocessor.
+ * Hence, we decrement spins_per_delay slowly when we had to delay,
+ * and increase it rapidly when we didn't. It's expected that
+ * spins_per_delay will converge to the minimum value on a uniprocessor
+ * and to the maximum value on a multiprocessor.
+ *
+ * Note: spins_per_delay is local within our current process.
+ * We want to average these observations across multiple backends,
+ * since it's relatively rare for this function to even get entered,
+ * and so a single backend might not live long enough to converge on
+ * a good value. That is handled by the two routines below.
+ */
+ if (cur_delay == 0)
+ {
+ /* we never had to delay */
+ if (spins_per_delay < MAX_SPINS_PER_DELAY)
+ spins_per_delay = Min(spins_per_delay + 100, MAX_SPINS_PER_DELAY);
+ }
+ else
+ {
+ if (spins_per_delay > MIN_SPINS_PER_DELAY)
+ spins_per_delay = Max(spins_per_delay - 1, MIN_SPINS_PER_DELAY);
+ }
+}
+
+
+/*
+ * Set local copy of spins_per_delay during backend startup.
+ *
+ * NB: this has to be pretty fast as it is called while holding a spinlock
+ */
+void
+set_spins_per_delay(int shared_spins_per_delay)
+{
+ spins_per_delay = shared_spins_per_delay;
+}
+
+/*
+ * Update shared estimate of spins_per_delay during backend exit.
+ *
+ * NB: this has to be pretty fast as it is called while holding a spinlock
+ */
+int
+update_spins_per_delay(int shared_spins_per_delay)
+{
+ /*
+ * We use an exponential moving average with a relatively slow
+ * adaption rate, so that noise in any one backend's result won't
+ * affect the shared value too much. As long as both inputs are
+ * within the allowed range, the result must be too, so we need not
+ * worry about clamping the result.
+ *
+ * We deliberately truncate rather than rounding; this is so that
+ * single adjustments inside a backend can affect the shared estimate
+ * (see the asymmetric adjustment rules above).
+ */
+ return (shared_spins_per_delay * 15 + spins_per_delay) / 16;
}
+
/*
* Various TAS implementations that cannot live in s_lock.h as no inline
* definition exists (yet).
diff --git a/src/include/storage/proc.h b/src/include/storage/proc.h
index 7297f444bfd7ef2588da6eb1721627ab4ffd1a2f..b915f78035ef4596219d40d4ea523443c7b4807f 100644
--- a/src/include/storage/proc.h
+++ b/src/include/storage/proc.h
@@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/storage/proc.h,v 1.82 2005/09/19 17:21:48 momjian Exp $
+ * $PostgreSQL: pgsql/src/include/storage/proc.h,v 1.83 2005/10/11 20:41:32 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -105,6 +105,8 @@ typedef struct PROC_HDR
{
/* Head of list of free PGPROC structures */
SHMEM_OFFSET freeProcs;
+ /* Current shared estimate of appropriate spins_per_delay value */
+ int spins_per_delay;
} PROC_HDR;
diff --git a/src/include/storage/s_lock.h b/src/include/storage/s_lock.h
index 9c8b71820f36aa67c0fd1f161e3cd86410742c02..7b94d64c73dff66b015eed485f9c5470498273b8 100644
--- a/src/include/storage/s_lock.h
+++ b/src/include/storage/s_lock.h
@@ -66,7 +66,7 @@
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/storage/s_lock.h,v 1.141 2005/10/11 20:01:30 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/storage/s_lock.h,v 1.142 2005/10/11 20:41:32 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -872,4 +872,10 @@ extern int tas(volatile slock_t *lock); /* in port/.../tas.s, or
*/
extern void s_lock(volatile slock_t *lock, const char *file, int line);
+/* Support for dynamic adjustment of spins_per_delay */
+#define DEFAULT_SPINS_PER_DELAY 100
+
+extern void set_spins_per_delay(int shared_spins_per_delay);
+extern int update_spins_per_delay(int shared_spins_per_delay);
+
#endif /* S_LOCK_H */