Use WaitLatch, not pg_usleep, for delaying in pg_sleep().

This avoids platform-dependent behavior wherein pg_sleep() might fail to be
interrupted by statement timeout, query cancel, SIGTERM, etc.  Also, since
there's no reason to wake up once a second any more, we can reduce the
power consumption of a sleeping backend a tad.

Back-patch to 9.3, since use of SA_RESTART for SIGALRM makes this a bigger
issue than it used to be.

diff --git a/src/backend/utils/adt/misc.c b/src/backend/utils/adt/misc.c
index bf06ec048ff92e8c2326b72160d983b3b8aa0d7d..aecdcd056cd3834f88cef9b5a2988d086870fbdd 100644 (file)
--- a/src/backend/utils/adt/misc.c
+++ b/src/backend/utils/adt/misc.c
@@ -384,16 +384,16 @@ pg_sleep(PG_FUNCTION_ARGS)
    float8      endtime;
 
    /*
-    * We break the requested sleep into segments of no more than 1 second, to
-    * put an upper bound on how long it will take us to respond to a cancel
-    * or die interrupt.  (Note that pg_usleep is interruptible by signals on
-    * some platforms but not others.)  Also, this method avoids exposing
-    * pg_usleep's upper bound on allowed delays.
+    * We sleep using WaitLatch, to ensure that we'll wake up promptly if an
+    * important signal (such as SIGALRM or SIGINT) arrives.  Because
+    * WaitLatch's upper limit of delay is INT_MAX milliseconds, and the user
+    * might ask for more than that, we sleep for at most 10 minutes and then
+    * loop.
     *
     * By computing the intended stop time initially, we avoid accumulation of
     * extra delay across multiple sleeps.  This also ensures we won't delay
-    * less than the specified time if pg_usleep is interrupted by other
-    * signals such as SIGHUP.
+    * less than the specified time when WaitLatch is terminated early by a
+    * non-query-cancelling signal such as SIGHUP.
     */
 
 #ifdef HAVE_INT64_TIMESTAMP
@@ -407,15 +407,22 @@ pg_sleep(PG_FUNCTION_ARGS)
    for (;;)
    {
        float8      delay;
+       long        delay_ms;
 
        CHECK_FOR_INTERRUPTS();
+
        delay = endtime - GetNowFloat();
-       if (delay >= 1.0)
-           pg_usleep(1000000L);
+       if (delay >= 600.0)
+           delay_ms = 600000;
        else if (delay > 0.0)
-           pg_usleep((long) ceil(delay * 1000000.0));
+           delay_ms = (long) ceil(delay * 1000.0);
        else
            break;
+
+       (void) WaitLatch(&MyProc->procLatch,
+                        WL_LATCH_SET | WL_TIMEOUT,
+                        delay_ms);
+       ResetLatch(&MyProc->procLatch);
    }
 
    PG_RETURN_VOID();