Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Commit499abb0

Browse files
committed
Implement new 'lightweight lock manager' that's intermediate between
existing lock manager and spinlocks: it understands exclusive vs sharedlock but has few other fancy features. Replace most uses of spinlockswith lightweight locks. All remaining uses of spinlocks have very shortlock hold times (a few dozen instructions), so tweak spinlock backoffcode to work efficiently given this assumption. All per my proposal onpghackers 26-Sep-01.
1 parent818fb55 commit499abb0

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

46 files changed

+1588
-1348
lines changed

‎doc/src/sgml/wal.sgml‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
<!-- $Header: /cvsroot/pgsql/doc/src/sgml/wal.sgml,v 1.10 2001/09/22 03:59:17 momjian Exp $ -->
1+
<!-- $Header: /cvsroot/pgsql/doc/src/sgml/wal.sgml,v 1.11 2001/09/29 04:02:19 tgl Exp $ -->
22

33
<chapter id="wal">
44
<title>Write-Ahead Logging (<acronym>WAL</acronym>)</title>
@@ -146,7 +146,7 @@
146146
<para>
147147
The <acronym>WAL</acronym> buffers and control structure are in
148148
shared memory, and are handled by the backends; they are protected
149-
byspinlocks. The demand on shared memory is dependent on the
149+
bylightweight locks. The demand on shared memory is dependent on the
150150
number of buffers; the default size of the <acronym>WAL</acronym>
151151
buffers is 64 kB.
152152
</para>

‎src/backend/access/transam/clog.c‎

Lines changed: 41 additions & 44 deletions
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@
1313
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
1414
* Portions Copyright (c) 1994, Regents of the University of California
1515
*
16-
* $Header: /cvsroot/pgsql/src/backend/access/transam/clog.c,v 1.3 2001/08/26 16:55:59 tgl Exp $
16+
* $Header: /cvsroot/pgsql/src/backend/access/transam/clog.c,v 1.4 2001/09/29 04:02:21 tgl Exp $
1717
*
1818
*-------------------------------------------------------------------------
1919
*/
@@ -27,7 +27,7 @@
2727
#include<unistd.h>
2828

2929
#include"access/clog.h"
30-
#include"storage/s_lock.h"
30+
#include"storage/lwlock.h"
3131
#include"miscadmin.h"
3232

3333

@@ -74,8 +74,8 @@
7474
* The management algorithm is straight LRU except that we will never swap
7575
* out the latest page (since we know it's going to be hit again eventually).
7676
*
77-
* We use an overallspinlock to protect the shared data structures, plus
78-
* per-bufferspinlocks that synchronize I/O for each buffer. A process
77+
* We use an overallLWLock to protect the shared data structures, plus
78+
* per-bufferLWLocks that synchronize I/O for each buffer. A process
7979
* that is reading in or writing out a page buffer does not hold the control
8080
* lock, only the per-buffer lock for the buffer it is working on.
8181
*
@@ -105,10 +105,6 @@
105105
* by setting the page's state from WRITE_IN_PROGRESS to DIRTY. The writing
106106
* process must notice this and not mark the page CLEAN when it's done.
107107
*
108-
* XXX it's probably okay to use a spinlock for the control lock, since
109-
* that lock is only held for very short operations. It'd be nice to use
110-
* some other form of lock for the per-buffer I/O locks, however.
111-
*
112108
* XLOG interactions: this module generates an XLOG record whenever a new
113109
* CLOG page is initialized to zeroes. Other writes of CLOG come from
114110
* recording of transaction commit or abort in xact.c, which generates its
@@ -121,7 +117,6 @@
121117
* synchronization already.
122118
*----------
123119
*/
124-
#defineNUM_CLOG_BUFFERS8
125120

126121
typedefenum
127122
{
@@ -153,13 +148,17 @@ typedef struct ClogCtlData
153148
* swapping out the latest page.
154149
*/
155150
intlatest_page_number;
156-
157-
slock_tcontrol_lck;/* Lock for ClogCtlData itself */
158-
slock_tbuffer_lck[NUM_CLOG_BUFFERS];/* Per-buffer I/O locks */
159151
}ClogCtlData;
160152

161153
staticClogCtlData*ClogCtl=NULL;
162154

155+
/*
156+
* ClogBufferLocks is set during CLOGShmemInit and does not change thereafter.
157+
* The value is automatically inherited by backends via fork, and
158+
* doesn't need to be in shared memory.
159+
*/
160+
staticLWLockIdClogBufferLocks[NUM_CLOG_BUFFERS];/* Per-buffer I/O locks */
161+
163162
/*
164163
* ClogDir is set during CLOGShmemInit and does not change thereafter.
165164
* The value is automatically inherited by backends via fork, and
@@ -211,7 +210,7 @@ TransactionIdSetStatus(TransactionId xid, XidStatus status)
211210
Assert(status==TRANSACTION_STATUS_COMMITTED||
212211
status==TRANSACTION_STATUS_ABORTED);
213212

214-
S_LOCK(&(ClogCtl->control_lck));
213+
LWLockAcquire(CLogControlLock,LW_EXCLUSIVE);
215214

216215
slotno=ReadCLOGPage(pageno);
217216
byteptr=ClogCtl->page_buffer[slotno]+byteno;
@@ -224,7 +223,7 @@ TransactionIdSetStatus(TransactionId xid, XidStatus status)
224223

225224
ClogCtl->page_status[slotno]=CLOG_PAGE_DIRTY;
226225

227-
S_UNLOCK(&(ClogCtl->control_lck));
226+
LWLockRelease(CLogControlLock);
228227
}
229228

230229
/*
@@ -243,14 +242,14 @@ TransactionIdGetStatus(TransactionId xid)
243242
char*byteptr;
244243
XidStatusstatus;
245244

246-
S_LOCK(&(ClogCtl->control_lck));
245+
LWLockAcquire(CLogControlLock,LW_EXCLUSIVE);
247246

248247
slotno=ReadCLOGPage(pageno);
249248
byteptr=ClogCtl->page_buffer[slotno]+byteno;
250249

251250
status= (*byteptr >>bshift)&CLOG_XACT_BITMASK;
252251

253-
S_UNLOCK(&(ClogCtl->control_lck));
252+
LWLockRelease(CLogControlLock);
254253

255254
returnstatus;
256255
}
@@ -283,15 +282,13 @@ CLOGShmemInit(void)
283282

284283
memset(ClogCtl,0,sizeof(ClogCtlData));
285284

286-
S_INIT_LOCK(&(ClogCtl->control_lck));
287-
288285
bufptr= ((char*)ClogCtl)+sizeof(ClogCtlData);
289286

290287
for (slotno=0;slotno<NUM_CLOG_BUFFERS;slotno++)
291288
{
292289
ClogCtl->page_buffer[slotno]=bufptr;
293290
ClogCtl->page_status[slotno]=CLOG_PAGE_EMPTY;
294-
S_INIT_LOCK(&(ClogCtl->buffer_lck[slotno]));
291+
ClogBufferLocks[slotno]=LWLockAssign();
295292
bufptr+=CLOG_BLCKSZ;
296293
}
297294

@@ -312,7 +309,7 @@ BootStrapCLOG(void)
312309
{
313310
intslotno;
314311

315-
S_LOCK(&(ClogCtl->control_lck));
312+
LWLockAcquire(CLogControlLock,LW_EXCLUSIVE);
316313

317314
/* Create and zero the first page of the commit log */
318315
slotno=ZeroCLOGPage(0, false);
@@ -321,7 +318,7 @@ BootStrapCLOG(void)
321318
WriteCLOGPage(slotno);
322319
Assert(ClogCtl->page_status[slotno]==CLOG_PAGE_CLEAN);
323320

324-
S_UNLOCK(&(ClogCtl->control_lck));
321+
LWLockRelease(CLogControlLock);
325322
}
326323

327324
/*
@@ -411,8 +408,8 @@ ReadCLOGPage(int pageno)
411408
ClogCtl->page_lru_count[slotno]=0;
412409

413410
/* Release shared lock, grab per-buffer lock instead */
414-
S_UNLOCK(&(ClogCtl->control_lck));
415-
S_LOCK(&(ClogCtl->buffer_lck[slotno]));
411+
LWLockRelease(CLogControlLock);
412+
LWLockAcquire(ClogBufferLocks[slotno],LW_EXCLUSIVE);
416413

417414
/*
418415
* Check to see if someone else already did the read, or took the
@@ -421,23 +418,23 @@ ReadCLOGPage(int pageno)
421418
if (ClogCtl->page_number[slotno]!=pageno||
422419
ClogCtl->page_status[slotno]!=CLOG_PAGE_READ_IN_PROGRESS)
423420
{
424-
S_UNLOCK(&(ClogCtl->buffer_lck[slotno]));
425-
S_LOCK(&(ClogCtl->control_lck));
421+
LWLockRelease(ClogBufferLocks[slotno]);
422+
LWLockAcquire(CLogControlLock,LW_EXCLUSIVE);
426423
continue;
427424
}
428425

429426
/* Okay, do the read */
430427
CLOGPhysicalReadPage(pageno,slotno);
431428

432429
/* Re-acquire shared control lock and update page state */
433-
S_LOCK(&(ClogCtl->control_lck));
430+
LWLockAcquire(CLogControlLock,LW_EXCLUSIVE);
434431

435432
Assert(ClogCtl->page_number[slotno]==pageno&&
436433
ClogCtl->page_status[slotno]==CLOG_PAGE_READ_IN_PROGRESS);
437434

438435
ClogCtl->page_status[slotno]=CLOG_PAGE_CLEAN;
439436

440-
S_UNLOCK(&(ClogCtl->buffer_lck[slotno]));
437+
LWLockRelease(ClogBufferLocks[slotno]);
441438

442439
ClogRecentlyUsed(slotno);
443440
returnslotno;
@@ -468,8 +465,8 @@ WriteCLOGPage(int slotno)
468465
pageno=ClogCtl->page_number[slotno];
469466

470467
/* Release shared lock, grab per-buffer lock instead */
471-
S_UNLOCK(&(ClogCtl->control_lck));
472-
S_LOCK(&(ClogCtl->buffer_lck[slotno]));
468+
LWLockRelease(CLogControlLock);
469+
LWLockAcquire(ClogBufferLocks[slotno],LW_EXCLUSIVE);
473470

474471
/*
475472
* Check to see if someone else already did the write, or took the
@@ -482,8 +479,8 @@ WriteCLOGPage(int slotno)
482479
(ClogCtl->page_status[slotno]!=CLOG_PAGE_DIRTY&&
483480
ClogCtl->page_status[slotno]!=CLOG_PAGE_WRITE_IN_PROGRESS))
484481
{
485-
S_UNLOCK(&(ClogCtl->buffer_lck[slotno]));
486-
S_LOCK(&(ClogCtl->control_lck));
482+
LWLockRelease(ClogBufferLocks[slotno]);
483+
LWLockAcquire(CLogControlLock,LW_EXCLUSIVE);
487484
return;
488485
}
489486

@@ -504,7 +501,7 @@ WriteCLOGPage(int slotno)
504501
CLOGPhysicalWritePage(pageno,slotno);
505502

506503
/* Re-acquire shared control lock and update page state */
507-
S_LOCK(&(ClogCtl->control_lck));
504+
LWLockAcquire(CLogControlLock,LW_EXCLUSIVE);
508505

509506
Assert(ClogCtl->page_number[slotno]==pageno&&
510507
(ClogCtl->page_status[slotno]==CLOG_PAGE_WRITE_IN_PROGRESS||
@@ -514,7 +511,7 @@ WriteCLOGPage(int slotno)
514511
if (ClogCtl->page_status[slotno]==CLOG_PAGE_WRITE_IN_PROGRESS)
515512
ClogCtl->page_status[slotno]=CLOG_PAGE_CLEAN;
516513

517-
S_UNLOCK(&(ClogCtl->buffer_lck[slotno]));
514+
LWLockRelease(ClogBufferLocks[slotno]);
518515
}
519516

520517
/*
@@ -714,7 +711,7 @@ ShutdownCLOG(void)
714711
{
715712
intslotno;
716713

717-
S_LOCK(&(ClogCtl->control_lck));
714+
LWLockAcquire(CLogControlLock,LW_EXCLUSIVE);
718715

719716
for (slotno=0;slotno<NUM_CLOG_BUFFERS;slotno++)
720717
{
@@ -723,7 +720,7 @@ ShutdownCLOG(void)
723720
ClogCtl->page_status[slotno]==CLOG_PAGE_CLEAN);
724721
}
725722

726-
S_UNLOCK(&(ClogCtl->control_lck));
723+
LWLockRelease(CLogControlLock);
727724
}
728725

729726
/*
@@ -734,7 +731,7 @@ CheckPointCLOG(void)
734731
{
735732
intslotno;
736733

737-
S_LOCK(&(ClogCtl->control_lck));
734+
LWLockAcquire(CLogControlLock,LW_EXCLUSIVE);
738735

739736
for (slotno=0;slotno<NUM_CLOG_BUFFERS;slotno++)
740737
{
@@ -745,7 +742,7 @@ CheckPointCLOG(void)
745742
*/
746743
}
747744

748-
S_UNLOCK(&(ClogCtl->control_lck));
745+
LWLockRelease(CLogControlLock);
749746
}
750747

751748

@@ -772,12 +769,12 @@ ExtendCLOG(TransactionId newestXact)
772769

773770
pageno=TransactionIdToPage(newestXact);
774771

775-
S_LOCK(&(ClogCtl->control_lck));
772+
LWLockAcquire(CLogControlLock,LW_EXCLUSIVE);
776773

777774
/* Zero the page and make an XLOG entry about it */
778775
ZeroCLOGPage(pageno, true);
779776

780-
S_UNLOCK(&(ClogCtl->control_lck));
777+
LWLockRelease(CLogControlLock);
781778
}
782779

783780

@@ -819,7 +816,7 @@ TruncateCLOG(TransactionId oldestXact)
819816
* should have been flushed already during the checkpoint, we're
820817
* just being extra careful here.)
821818
*/
822-
S_LOCK(&(ClogCtl->control_lck));
819+
LWLockAcquire(CLogControlLock,LW_EXCLUSIVE);
823820

824821
restart:;
825822
/*
@@ -830,7 +827,7 @@ restart:;
830827
*/
831828
if (CLOGPagePrecedes(ClogCtl->latest_page_number,cutoffPage))
832829
{
833-
S_UNLOCK(&(ClogCtl->control_lck));
830+
LWLockRelease(CLogControlLock);
834831
elog(LOG,"unable to truncate commit log: apparent wraparound");
835832
return;
836833
}
@@ -861,7 +858,7 @@ restart:;
861858
gotorestart;
862859
}
863860

864-
S_UNLOCK(&(ClogCtl->control_lck));
861+
LWLockRelease(CLogControlLock);
865862

866863
/* Now we can remove the old CLOG segment(s) */
867864
(void)ScanCLOGDirectory(cutoffPage, true);
@@ -974,13 +971,13 @@ clog_redo(XLogRecPtr lsn, XLogRecord *record)
974971

975972
memcpy(&pageno,XLogRecGetData(record),sizeof(int));
976973

977-
S_LOCK(&(ClogCtl->control_lck));
974+
LWLockAcquire(CLogControlLock,LW_EXCLUSIVE);
978975

979976
slotno=ZeroCLOGPage(pageno, false);
980977
WriteCLOGPage(slotno);
981978
Assert(ClogCtl->page_status[slotno]==CLOG_PAGE_CLEAN);
982979

983-
S_UNLOCK(&(ClogCtl->control_lck));
980+
LWLockRelease(CLogControlLock);
984981
}
985982
}
986983

0 commit comments

Comments
 (0)
[8]ページ先頭
©2009-2025 Movatter.jp