Skip to content

Commit acac68b

Browse files
alvherrealvherre
committed
Allow an autovacuum worker to be interrupted automatically when it is found
to be locking another process (except when it's working to prevent Xid wraparound problems).
1 parent ffda32e commit acac68b

File tree

5 files changed

+114
-7
lines changed

5 files changed

+114
-7
lines changed

‎src/backend/postmaster/autovacuum.c

Lines changed: 9 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -55,7 +55,7 @@
5555
*
5656
*
5757
* IDENTIFICATION
58-
* $PostgreSQL: pgsql/src/backend/postmaster/autovacuum.c,v 1.65 2007/10/25 19:13:37 alvherre Exp $
58+
* $PostgreSQL: pgsql/src/backend/postmaster/autovacuum.c,v 1.66 2007/10/26 20:45:10 alvherre Exp $
5959
*
6060
*-------------------------------------------------------------------------
6161
*/
@@ -2120,6 +2120,14 @@ do_autovacuum(void)
21202120
tab->at_doanalyze,
21212121
tab->at_freeze_min_age,
21222122
bstrategy);
2123+
2124+
/*
2125+
* Clear a possible query-cancel signal, to avoid a late reaction
2126+
* to an automatically-sent signal because of vacuuming the current
2127+
* table (we're done with it, so it would make no sense to cancel
2128+
* at this point.)
2129+
*/
2130+
QueryCancelPending = false;
21232131
}
21242132
PG_CATCH();
21252133
{

‎src/backend/storage/lmgr/README

Lines changed: 8 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
$PostgreSQL: pgsql/src/backend/storage/lmgr/README,v 1.21 2006/09/18 22:40:36 tgl Exp $
1+
$PostgreSQL: pgsql/src/backend/storage/lmgr/README,v 1.22 2007/10/26 20:45:10 alvherre Exp $
22

33

44
LOCKING OVERVIEW
@@ -487,6 +487,13 @@ seems a safer approach than trying to allocate workspace on the fly; we
487487
don't want to risk having the deadlock detector run out of memory, else
488488
we really have no guarantees at all that deadlock will be detected.
489489

490+
6. We abuse the deadlock detector to implement autovacuum cancellation.
491+
When we run the detector and we find that there's an autovacuum worker
492+
involved in the waits-for graph, we store a pointer to its PGPROC, and
493+
return a special return code (unless a hard deadlock has been detected).
494+
The caller can then send a cancellation signal. This implements the
495+
principle that autovacuum has a low locking priority (eg it must not block
496+
DDL on the table).
490497

491498
USER LOCKS
492499

‎src/backend/storage/lmgr/deadlock.c

Lines changed: 44 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,7 @@
1212
*
1313
*
1414
* IDENTIFICATION
15-
* $PostgreSQL: pgsql/src/backend/storage/lmgr/deadlock.c,v 1.48 2007/06/19 20:13:21 tgl Exp $
15+
* $PostgreSQL: pgsql/src/backend/storage/lmgr/deadlock.c,v 1.49 2007/10/26 20:45:10 alvherre Exp $
1616
*
1717
* Interface:
1818
*
@@ -109,6 +109,9 @@ static int maxPossibleConstraints;
109109
static DEADLOCK_INFO *deadlockDetails;
110110
static int nDeadlockDetails;
111111

112+
/* PGPROC pointer of any blocking autovacuum worker found */
113+
static PGPROC *blocking_autovacuum_proc = NULL;
114+
112115

113116
/*
114117
* InitDeadLockChecking -- initialize deadlock checker during backend startup
@@ -206,6 +209,9 @@ DeadLockCheck(PGPROC *proc)
206209
nPossibleConstraints = 0;
207210
nWaitOrders = 0;
208211

212+
/* Initialize to not blocked by an autovacuum worker */
213+
blocking_autovacuum_proc = NULL;
214+
209215
/* Search for deadlocks and possible fixes */
210216
if (DeadLockCheckRecurse(proc))
211217
{
@@ -255,10 +261,28 @@ DeadLockCheck(PGPROC *proc)
255261
/* Return code tells caller if we had to escape a deadlock or not */
256262
if (nWaitOrders > 0)
257263
return DS_SOFT_DEADLOCK;
264+
else if (blocking_autovacuum_proc != NULL)
265+
return DS_BLOCKED_BY_AUTOVACUUM;
258266
else
259267
return DS_NO_DEADLOCK;
260268
}
261269

270+
/*
271+
* Return the PGPROC of the autovacuum that's blocking a process.
272+
*
273+
* We reset the saved pointer as soon as we pass it back.
274+
*/
275+
PGPROC *
276+
GetBlockingAutoVacuumPgproc(void)
277+
{
278+
PGPROC *ptr;
279+
280+
ptr = blocking_autovacuum_proc;
281+
blocking_autovacuum_proc = NULL;
282+
283+
return ptr;
284+
}
285+
262286
/*
263287
* DeadLockCheckRecurse -- recursively search for valid orderings
264288
*
@@ -497,6 +521,25 @@ FindLockCycleRecurse(PGPROC *checkProc,
497521
if ((proclock->holdMask & LOCKBIT_ON(lm)) &&
498522
(conflictMask & LOCKBIT_ON(lm)))
499523
{
524+
/*
525+
* Look for a blocking autovacuum. There can be more than
526+
* one in the deadlock cycle, in which case we just pick a
527+
* random one. We stash the autovacuum worker's PGPROC so
528+
* that the caller can send a cancel signal to it, if
529+
* appropriate.
530+
*
531+
* Note we read vacuumFlags without any locking. This is
532+
* OK only for checking the PROC_IS_AUTOVACUUM flag,
533+
* because that flag is set at process start and never
534+
* reset; there is logic elsewhere to avoid cancelling an
535+
* autovacuum that is working for preventing Xid wraparound
536+
* problems (which needs to read a different vacuumFlag
537+
* bit), but we don't do that here to avoid grabbing
538+
* ProcArrayLock.
539+
*/
540+
if (proc->vacuumFlags & PROC_IS_AUTOVACUUM)
541+
blocking_autovacuum_proc = proc;
542+
500543
/* This proc hard-blocks checkProc */
501544
if (FindLockCycleRecurse(proc, depth + 1,
502545
softEdges, nSoftEdges))

‎src/backend/storage/lmgr/proc.c

Lines changed: 48 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@
88
*
99
*
1010
* IDENTIFICATION
11-
* $PostgreSQL: pgsql/src/backend/storage/lmgr/proc.c,v 1.195 2007/10/24 20:55:36 alvherre Exp $
11+
* $PostgreSQL: pgsql/src/backend/storage/lmgr/proc.c,v 1.196 2007/10/26 20:45:10 alvherre Exp $
1212
*
1313
*-------------------------------------------------------------------------
1414
*/
@@ -734,6 +734,7 @@ ProcSleep(LOCALLOCK *locallock, LockMethod lockMethodTable)
734734
PROC_QUEUE *waitQueue = &(lock->waitProcs);
735735
LOCKMASK myHeldLocks = MyProc->heldLocks;
736736
bool early_deadlock = false;
737+
bool allow_autovacuum_cancel = true;
737738
int myWaitStatus;
738739
PGPROC *proc;
739740
int i;
@@ -893,6 +894,48 @@ ProcSleep(LOCALLOCK *locallock, LockMethod lockMethodTable)
893894
*/
894895
myWaitStatus = MyProc->waitStatus;
895896

897+
/*
898+
* If we are not deadlocked, but are waiting on an autovacuum-induced
899+
* task, send a signal to interrupt it.
900+
*/
901+
if (deadlock_state == DS_BLOCKED_BY_AUTOVACUUM && allow_autovacuum_cancel)
902+
{
903+
PGPROC *autovac = GetBlockingAutoVacuumPgproc();
904+
905+
LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
906+
907+
/*
908+
* Only do it if the worker is not working to protect against Xid
909+
* wraparound.
910+
*/
911+
if ((autovac != NULL) &&
912+
(autovac->vacuumFlags & PROC_IS_AUTOVACUUM) &&
913+
!(autovac->vacuumFlags & PROC_VACUUM_FOR_WRAPAROUND))
914+
{
915+
int pid = autovac->pid;
916+
917+
elog(DEBUG2, "sending cancel to blocking autovacuum pid = %d",
918+
pid);
919+
920+
/* don't hold the lock across the kill() syscall */
921+
LWLockRelease(ProcArrayLock);
922+
923+
/* send the autovacuum worker Back to Old Kent Road */
924+
if (kill(pid, SIGINT) < 0)
925+
{
926+
/* Just a warning to allow multiple callers */
927+
ereport(WARNING,
928+
(errmsg("could not send signal to process %d: %m",
929+
pid)));
930+
}
931+
}
932+
else
933+
LWLockRelease(ProcArrayLock);
934+
935+
/* prevent signal from being resent more than once */
936+
allow_autovacuum_cancel = false;
937+
}
938+
896939
/*
897940
* If awoken after the deadlock check interrupt has run, and
898941
* log_lock_waits is on, then report about the wait.
@@ -1189,13 +1232,16 @@ CheckDeadLock(void)
11891232
* RemoveFromWaitQueue took care of waking up any such processes.
11901233
*/
11911234
}
1192-
else if (log_lock_waits)
1235+
else if (log_lock_waits || deadlock_state == DS_BLOCKED_BY_AUTOVACUUM)
11931236
{
11941237
/*
11951238
* Unlock my semaphore so that the interrupted ProcSleep() call can
11961239
* print the log message (we daren't do it here because we are inside
11971240
* a signal handler). It will then sleep again until someone
11981241
* releases the lock.
1242+
*
1243+
* If blocked by autovacuum, this wakeup will enable ProcSleep to send
1244+
* the cancelling signal to the autovacuum worker.
11991245
*/
12001246
PGSemaphoreUnlock(&MyProc->sem);
12011247
}

‎src/include/storage/lock.h

Lines changed: 5 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@
77
* Portions Copyright (c) 1996-2007, PostgreSQL Global Development Group
88
* Portions Copyright (c) 1994, Regents of the University of California
99
*
10-
* $PostgreSQL: pgsql/src/include/storage/lock.h,v 1.107 2007/09/05 18:10:48 tgl Exp $
10+
* $PostgreSQL: pgsql/src/include/storage/lock.h,v 1.108 2007/10/26 20:45:10 alvherre Exp $
1111
*
1212
*-------------------------------------------------------------------------
1313
*/
@@ -442,7 +442,9 @@ typedef enum
442442
DS_NOT_YET_CHECKED, /* no deadlock check has run yet */
443443
DS_NO_DEADLOCK, /* no deadlock detected */
444444
DS_SOFT_DEADLOCK, /* deadlock avoided by queue rearrangement */
445-
DS_HARD_DEADLOCK /* deadlock, no way out but ERROR */
445+
DS_HARD_DEADLOCK, /* deadlock, no way out but ERROR */
446+
DS_BLOCKED_BY_AUTOVACUUM /* no deadlock; queue blocked by autovacuum
447+
worker */
446448
} DeadLockState;
447449

448450

@@ -495,6 +497,7 @@ extern void lock_twophase_postabort(TransactionId xid, uint16 info,
495497
void *recdata, uint32 len);
496498

497499
extern DeadLockState DeadLockCheck(PGPROC *proc);
500+
extern PGPROC *GetBlockingAutoVacuumPgproc(void);
498501
extern void DeadLockReport(void);
499502
extern void RememberSimpleDeadLock(PGPROC *proc1,
500503
LOCKMODE lockmode,

0 commit comments

Comments
 (0)