Adopt a random backoff algorithm for sleep delays when waiting for a

spinlock.  Per recent pghackers discussion.

diff --git a/src/backend/storage/lmgr/s_lock.c b/src/backend/storage/lmgr/s_lock.c
index ff37daaa251be5e0f5636346fe04d6df4ccc6197..de6b355aace303e2997d9e74d1b525f59b436c33 100644 (file)
--- a/src/backend/storage/lmgr/s_lock.c
+++ b/src/backend/storage/lmgr/s_lock.c
@@ -9,7 +9,7 @@
  *
  *
  * IDENTIFICATION
- *   $Header: /cvsroot/pgsql/src/backend/storage/lmgr/s_lock.c,v 1.14 2003/08/04 15:28:33 tgl Exp $
+ *   $Header: /cvsroot/pgsql/src/backend/storage/lmgr/s_lock.c,v 1.15 2003/08/06 16:43:43 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -31,7 +31,7 @@ s_lock_stuck(volatile slock_t *lock, const char *file, int line)
    fprintf(stderr,
            "\nStuck spinlock (%p) detected at %s:%d.\n",
            lock, file, line);
-   abort();
+   exit(1);
 #else
    elog(PANIC, "stuck spinlock (%p) detected at %s:%d",
         lock, file, line);
@@ -45,35 +45,68 @@ s_lock_stuck(volatile slock_t *lock, const char *file, int line)
 void
 s_lock(volatile slock_t *lock, const char *file, int line)
 {
-   unsigned    spins = 0;
-   unsigned    delays = 0;
-   struct timeval delay;
-
    /*
     * We loop tightly for awhile, then delay using select() 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.
+    * 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.
+    *
+    * Once we do decide to block, we use randomly increasing select() delays.
+    * The first delay is 10 msec, then the delay randomly increases to about
+    * one second, after which we reset to 10 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 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 use a 10 millisec select delay because that is the lower limit on
-    * many platforms.  The timeout is figured on this delay only, and so
-    * the nominal 1 minute is a lower bound.
+    * 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 (and
+    * thus the probability of unintended failure) than to fix the total time
+    * spent.
+    *
+    * The select() delays are measured in centiseconds (0.01 sec) because
+    * 10 msec is a common resolution limit at the OS level.
     */
 #define SPINS_PER_DELAY        100
-#define DELAY_MSEC         10
-#define TIMEOUT_MSEC       (60 * 1000)
+#define NUM_DELAYS         1000
+#define MIN_DELAY_CSEC     1
+#define MAX_DELAY_CSEC     100
+
+   int         spins = 0;
+   int         delays = 0;
+   int         cur_delay = MIN_DELAY_CSEC;
+   struct timeval delay;
 
    while (TAS(lock))
    {
        if (++spins > SPINS_PER_DELAY)
        {
-           if (++delays > (TIMEOUT_MSEC / DELAY_MSEC))
+           if (++delays > NUM_DELAYS)
                s_lock_stuck(lock, file, line);
 
-           delay.tv_sec = 0;
-           delay.tv_usec = DELAY_MSEC * 1000;
+           delay.tv_sec = cur_delay / 100;
+           delay.tv_usec = (cur_delay % 100) * 10000;
            (void) select(0, NULL, NULL, NULL, &delay);
 
+#if defined(S_LOCK_TEST)
+           fprintf(stdout, "*"); fflush(stdout);
+#endif
+
+           /* increase delay by a random fraction between 1X and 2X */
+           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;
+
            spins = 0;
        }
    }
@@ -217,6 +250,8 @@ volatile slock_t test_lock;
 int
 main()
 {
+   srandom((unsigned int) time(NULL));
+
    S_INIT_LOCK(&test_lock);
 
    if (!S_LOCK_FREE(&test_lock))
@@ -249,9 +284,9 @@ main()
        return 1;
    }
 
-   printf("S_LOCK_TEST: this will hang for a minute or so and then abort\n");
-   printf("             with a 'stuck spinlock' message if S_LOCK()\n");
-   printf("             and TAS() are working.\n");
+   printf("S_LOCK_TEST: this will print %d stars and then\n", NUM_DELAYS);
+   printf("             exit with a 'stuck spinlock' message\n");
+   printf("             if S_LOCK() and TAS() are working.\n");
    fflush(stdout);
 
    s_lock(&test_lock, __FILE__, __LINE__);