mirror/postgresql
2
0
Fork 0
mirror of https://git.postgresql.org/git/postgresql.git synced 2025-01-06 15:24:56 +08:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
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.
This commit is contained in:
Tom Lane 2013-06-15 16:22:29 -04:00
parent f69aece6f4
commit a64ca63e59
1 changed files with 17 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
src/backend/utils/adt/misc.c
View File

@ -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();