8000 Rename assorted LWLock tranches. · postgres/postgres@36ac359 · GitHub
[go: up one dir, main page]
Skip to content

Commit 36ac359

Browse files
tglsfdctglsfdc
committed
Rename assorted LWLock tranches.
Choose names that fit into the conventions for wait event names (particularly, that multi-word names are in the style MultiWordName) and hopefully convey more information to non-hacker users than the previous names did. Also rename SerializablePredicateLockListLock to SerializablePredicateListLock; the old name was long enough to cause table formatting problems, plus the double occurrence of "Lock" seems confusing/error-prone. Also change a couple of particularly opaque LWLock field names. Discussion: https://postgr.es/m/28683.1589405363@sss.pgh.pa.us
1 parent a0ab4f4 commit 36ac359

File tree

15 files changed

+304
-260
lines changed

15 files changed

+304
-260
lines changed

‎doc/src/sgml/monitoring.sgml

Lines changed: 163 additions & 132 deletions
Large diffs are not rendered by default.

‎src/backend/access/common/session.c

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -117,7 +117,7 @@ GetSessionDsmHandle(void)
117117
dsa_space = shm_toc_allocate(toc, SESSION_DSA_SIZE);
118118
dsa = dsa_create_in_place(dsa_space,
119119
SESSION_DSA_SIZE,
120-
LWTRANCHE_SESSION_DSA,
120+
LWTRANCHE_PER_SESSION_DSA,
121121
seg);
122122
shm_toc_insert(toc, SESSION_KEY_DSA, dsa_space);
123123

‎src/backend/nodes/tidbitmap.c

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -889,7 +889,7 @@ tbm_prepare_shared_iterate(TIDBitmap *tbm)
889889
pg_atomic_add_fetch_u32(&ptchunks->refcount, 1);
890890

891891
/* Initialize the iterator lock */
892-
LWLockInitialize(&istate->lock, LWTRANCHE_TBM);
892+
LWLockInitialize(&istate->lock, LWTRANCHE_SHARED_TIDBITMAP);
893893

894894
/* Initialize the shared iterator state */
895895
istate->schunkbit = 0;

‎src/backend/replication/logical/origin.c

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -506,7 +506,7 @@ ReplicationOriginShmemInit(void)
506506
{
507507
int i;
508508

509-
replication_states_ctl->tranche_id = LWTRANCHE_REPLICATION_ORIGIN;
509+
replication_states_ctl->tranche_id = LWTRANCHE_REPLICATION_ORIGIN_STATE;
510510

511511
MemSet(replication_states, 0, ReplicationOriginShmemSize());
512512

‎src/backend/replication/slot.c

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -153,7 +153,8 @@ ReplicationSlotsShmemInit(void)
153153

154154
/* everything else is zeroed by the memset above */
155155
SpinLockInit(&slot->mutex);
156-
LWLockInitialize(&slot->io_in_progress_lock, LWTRANCHE_REPLICATION_SLOT_IO_IN_PROGRESS);
156+
LWLockInitialize(&slot->io_in_progress_lock,
157+
LWTRANCHE_REPLICATION_SLOT_IO);
157158
ConditionVariableInit(&slot->active_cv);
158159
}
159160
}

‎src/backend/storage/buffer/buf_init.c

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -132,7 +132,7 @@ InitBufferPool(void)
132132
LWTRANCHE_BUFFER_CONTENT);
133133

134134
LWLockInitialize(BufferDescriptorGetIOLock(buf),
135-
LWTRANCHE_BUFFER_IO_IN_PROGRESS);
135+
LWTRANCHE_BUFFER_IO);
136136
}
137137

138138
/* Correct last entry of linked list */

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

Lines changed: 31 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -936,13 +936,13 @@ LockAcquireExtended(const LOCKTAG *locktag,
936936
* FastPathStrongRelationLocks->counts becomes visible after we test
937937
* it has yet to begin to transfer fast-path locks.
938938
*/
939-
LWLockAcquire(&MyProc->backendLock, LW_EXCLUSIVE);
939+
LWLockAcquire(&MyProc->fpInfoLock, LW_EXCLUSIVE);
940940
if (FastPathStrongRelationLocks->count[fasthashcode] != 0)
941941
acquired = false;
942942
else
943943
acquired = FastPathGrantRelationLock(locktag->locktag_field2,
944944
lockmode);
945-
LWLockRelease(&MyProc->backendLock);
945+
LWLockRelease(&MyProc->fpInfoLock);
946946
if (acquired)
947947
{
948948
/*
@@ -2085,10 +2085,10 @@ LockRelease(const LOCKTAG *locktag, LOCKMODE lockmode, bool sessionLock)
20852085
* We might not find the lock here, even if we originally entered it
20862086
* here. Another backend may have moved it to the main table.
20872087
*/
2088-
LWLockAcquire(&MyProc->backendLock, LW_EXCLUSIVE);
2088+
LWLockAcquire(&MyProc->fpInfoLock, LW_EXCLUSIVE);
20892089
released = FastPathUnGrantRelationLock(locktag->locktag_field2,
20902090
lockmode);
2091-
LWLockRelease(&MyProc->backendLock);
2091+
LWLockRelease(&MyProc->fpInfoLock);
20922092
if (released)
20932093
{
20942094
RemoveLocalLock(locallock);
@@ -2291,7 +2291,7 @@ LockReleaseAll(LOCKMETHODID lockmethodid, bool allLocks)
22912291
*/
22922292
if (!have_fast_path_lwlock)
22932293
{
2294-
LWLockAcquire(&MyProc->backendLock, LW_EXCLUSIVE);
2294+
LWLockAcquire(&MyProc->fpInfoLock, LW_EXCLUSIVE);
22952295
have_fast_path_lwlock = true;
22962296
}
22972297

@@ -2308,7 +2308,7 @@ LockReleaseAll(LOCKMETHODID lockmethodid, bool allLocks)
23082308
* transferred to the main lock table. That's going to require
23092309
* some extra work, so release our fast-path lock before starting.
23102310
*/
2311-
LWLockRelease(&MyProc->backendLock);
2311+
LWLockRelease(&MyProc->fpInfoLock);
23122312
have_fast_path_lwlock = false;
23132313

23142314
/*
@@ -2334,7 +2334,7 @@ LockReleaseAll(LOCKMETHODID lockmethodid, bool allLocks)
23342334

23352335
/* Done with the fast-path data structures */
23362336
if (have_fast_path_lwlock)
2337-
LWLockRelease(&MyProc->backendLock);
2337+
LWLockRelease(&MyProc->fpInfoLock);
23382338

23392339
/*
23402340
* Now, scan each lock partition separately.
@@ -2737,7 +2737,7 @@ FastPathTransferRelationLocks(LockMethod lockMethodTable, const LOCKTAG *locktag
27372737
PGPROC *proc = &ProcGlobal->allProcs[i];
27382738
uint32 f;
27392739

2740-
LWLockAcquire(&proc->backendLock, LW_EXCLUSIVE);
2740+
LWLockAcquire(&proc->fpInfoLock, LW_EXCLUSIVE);
27412741

27422742
/*
27432743
* If the target backend isn't referencing the same database as the
@@ -2746,8 +2746,8 @@ FastPathTransferRelationLocks(LockMethod lockMethodTable, const LOCKTAG *locktag
27462746
*
27472747
* proc->databaseId is set at backend startup time and never changes
27482748
* thereafter, so it might be safe to perform this test before
2749-
* acquiring &proc->backendLock. In particular, it's certainly safe
2750-
* to assume that if the target backend holds any fast-path locks, it
2749+
* acquiring &proc->fpInfoLock. In particular, it's certainly safe to
2750+
* assume that if the target backend holds any fast-path locks, it
27512751
* must have performed a memory-fencing operation (in particular, an
27522752
* LWLock acquisition) since setting proc->databaseId. However, it's
27532753
* less clear that our backend is certain to have performed a memory
@@ -2756,7 +2756,7 @@ FastPathTransferRelationLocks(LockMethod lockMethodTable, const LOCKTAG *locktag
27562756
*/
27572757
if (proc->databaseId != locktag->locktag_field1)
27582758
{
2759-
LWLockRelease(&proc->backendLock);
2759+
LWLockRelease(&proc->fpInfoLock);
27602760
continue;
27612761
}
27622762

@@ -2783,7 +2783,7 @@ FastPathTransferRelationLocks(LockMethod lockMethodTable, const LOCKTAG *locktag
27832783
if (!proclock)
27842784
{
27852785
LWLockRelease(partitionLock);
2786-
LWLockRelease(&proc->backendLock);
2786+
LWLockRelease(&proc->fpInfoLock);
27872787
return false;
27882788
}
27892789
GrantLock(proclock->tag.myLock, proclock, lockmode);
@@ -2794,7 +2794,7 @@ FastPathTransferRelationLocks(LockMethod lockMethodTable, const LOCKTAG *locktag
27942794
/* No need to examine remaining slots. */
27952795
break;
27962796
}
2797-
LWLockRelease(&proc->backendLock);
2797+
LWLockRelease(&proc->fpInfoLock);
27982798
}
27992799
return true;
28002800
}
@@ -2816,7 +2816,7 @@ FastPathGetRelationLockEntry(LOCALLOCK *locallock)
28162816
Oid relid = locktag->locktag_field2;
28172817
uint32 f;
28182818

2819-
LWLockAcquire(&MyProc->backendLock, LW_EXCLUSIVE);
2819+
LWLockAcquire(&MyProc->fpInfoLock, LW_EXCLUSIVE);
28202820

28212821
for (f = 0; f < FP_LOCK_SLOTS_PER_BACKEND; f++)
28222822
{
@@ -2839,7 +2839,7 @@ FastPathGetRelationLockEntry(LOCALLOCK *locallock)
28392839
if (!proclock)
28402840
{
28412841
LWLockRelease(partitionLock);
2842-
LWLockRelease(&MyProc->backendLock);
2842+
LWLockRelease(&MyProc->fpInfoLock);
28432843
ereport(ERROR,
28442844
(errcode(ERRCODE_OUT_OF_MEMORY),
28452845
errmsg("out of shared memory"),
@@ -2854,7 +2854,7 @@ FastPathGetRelationLockEntry(LOCALLOCK *locallock)
28542854
break;
28552855
}
28562856

2857-
LWLockRelease(&MyProc->backendLock);
2857+
LWLockRelease(&MyProc->fpInfoLock);
28582858

28592859
/* Lock may have already been transferred by some other backend. */
28602860
if (proclock == NULL)
@@ -2980,7 +2980,7 @@ GetLockConflicts(const LOCKTAG *locktag, LOCKMODE lockmode, int *countp)
29802980
if (proc == MyProc)
29812981
continue;
29822982

2983-
LWLockAcquire(&proc->backendLock, LW_SHARED);
2983+
LWLockAcquire(&proc->fpInfoLock, LW_SHARED);
29842984

29852985
/*
29862986
* If the target backend isn't referencing the same database as
@@ -2992,7 +2992,7 @@ GetLockConflicts(const LOCKTAG *locktag, LOCKMODE lockmode, int *countp)
29922992
*/
29932993
if (proc->databaseId != locktag->locktag_field1)
29942994
{
2995-
LWLockRelease(&proc->backendLock);
2995+
LWLockRelease(&proc->fpInfoLock);
29962996
continue;
29972997
}
29982998

@@ -3030,7 +3030,7 @@ GetLockConflicts(const LOCKTAG *locktag, LOCKMODE lockmode, int *countp)
30303030
break;
30313031
}
30323032

3033-
LWLockRelease(&proc->backendLock);
3033+
LWLockRelease(&proc->fpInfoLock);
30343034
}
30353035
}
30363036

@@ -3599,7 +3599,7 @@ GetLockStatusData(void)
35993599
PGPROC *proc = &ProcGlobal->allProcs[i];
36003600
uint32 f;
36013601

3602-
LWLockAcquire(&proc->backendLock, LW_SHARED);
3602+
LWLockAcquire(&proc->fpInfoLock, LW_SHARED);
36033603

36043604
for (f = 0; f < FP_LOCK_SLOTS_PER_BACKEND; ++f)
36053605
{
@@ -3659,7 +3659,7 @@ GetLockStatusData(void)
36593659
el++;
36603660
}
36613661

3662-
LWLockRelease(&proc->backendLock);
3662+
LWLockRelease(&proc->fpInfoLock);
36633663
}
36643664

36653665
/*
@@ -4381,7 +4381,7 @@ lock_twophase_postabort(TransactionId xid, uint16 info,
43814381
* as MyProc->lxid, you might wonder if we really need both. The
43824382
* difference is that MyProc->lxid is set and cleared unlocked, and
43834383
* examined by procarray.c, while fpLocalTransactionId is protected by
4384-
* backendLock and is used only by the locking subsystem. Doing it this
4384+
* fpInfoLock and is used only by the locking subsystem. Doing it this
43854385
* way makes it easier to verify that there are no funny race conditions.
43864386
*
43874387
* We don't bother recording this lock in the local lock table, since it's
@@ -4393,7 +4393,7 @@ VirtualXactLockTableInsert(VirtualTransactionId vxid)
43934393
{
43944394
Assert(VirtualTransactionIdIsValid(vxid));
43954395

4396-
LWLockAcquire(&MyProc->backendLock, LW_EXCLUSIVE);
4396+
LWLockAcquire(&MyProc->fpInfoLock, LW_EXCLUSIVE);
43974397

43984398
Assert(MyProc->backendId == vxid.backendId);
43994399
Assert(MyProc->fpLocalTransactionId == InvalidLocalTransactionId);
@@ -4402,7 +4402,7 @@ VirtualXactLockTableInsert(VirtualTransactionId vxid)
44024402
MyProc->fpVXIDLock = true;
44034403
MyProc->fpLocalTransactionId = vxid.localTransactionId;
44044404

4405-
LWLockRelease(&MyProc->backendLock);
4405+
LWLockRelease(&MyProc->fpInfoLock);
44064406
}
44074407

44084408
/*
@@ -4422,14 +4422,14 @@ VirtualXactLockTableCleanup(void)
44224422
/*
44234423
* Clean up shared memory state.
44244424
*/
4425-
LWLockAcquire(&MyProc->backendLock, LW_EXCLUSIVE);
4425+
LWLockAcquire(&MyProc->fpInfoLock, LW_EXCLUSIVE);
44264426

44274427
fastpath = MyProc->fpVXIDLock;
44284428
lxid = MyProc->fpLocalTransactionId;
44294429
MyProc->fpVXIDLock = false;
44304430
MyProc->fpLocalTransactionId = InvalidLocalTransactionId;
44314431

4432-
LWLockRelease(&MyProc->backendLock);
4432+
LWLockRelease(&MyProc->fpInfoLock);
44334433

44344434
/*
44354435
* If fpVXIDLock has been cleared without touching fpLocalTransactionId,
@@ -4485,13 +4485,13 @@ VirtualXactLock(VirtualTransactionId vxid, bool wait)
44854485
* against the ones we're waiting for. The target backend will only set
44864486
* or clear lxid while holding this lock.
44874487
*/
4488-
LWLockAcquire(&proc->backendLock, LW_EXCLUSIVE);
4488+
LWLockAcquire(&proc->fpInfoLock, LW_EXCLUSIVE);
44894489

44904490
/* If the transaction has ended, our work here is done. */
44914491
if (proc->backendId != vxid.backendId
44924492
|| proc->fpLocalTransactionId != vxid.localTransactionId)
44934493
{
4494-
LWLockRelease(&proc->backendLock);
4494+
LWLockRelease(&proc->fpInfoLock);
44954495
return true;
44964496
}
44974497

@@ -4501,7 +4501,7 @@ VirtualXactLock(VirtualTransactionId vxid, bool wait)
45014501
*/
45024502
if (!wait)
45034503
{
4504-
LWLockRelease(&proc->backendLock);
4504+
LWLockRelease(&proc->fpInfoLock);
45054505
return false;
45064506
}
45074507

@@ -4526,7 +4526,7 @@ VirtualXactLock(VirtualTransactionId vxid, bool wait)
45264526
if (!proclock)
45274527
{
45284528
LWLockRelease(partitionLock);
4529-
LWLockRelease(&proc->backendLock);
4529+
LWLockRelease(&proc->fpInfoLock);
45304530
ereport(ERROR,
45314531
(errcode(ERRCODE_OUT_OF_MEMORY),
45324532
errmsg("out of shared memory"),
@@ -4540,7 +4540,7 @@ VirtualXactLock(VirtualTransactionId vxid, bool wait)
45404540
}
45414541

45424542
/* Done with proc->fpLockBits */
4543-
LWLockRelease(&proc->backendLock);
4543+
LWLockRelease(&proc->fpInfoLock);
45444544

45454545
/* Time to wait. */
45464546
(void) LockAcquire(&tag, ShareLock, false, false);

0 commit comments

Comments
 (0)
0