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

Commit8fad2e3

Browse files
committed
Arrange for GetSnapshotData to copy live-subtransaction XIDs from the
PGPROC array into snapshots, and use this information to avoid visitsto pg_subtrans in HeapTupleSatisfiesSnapshot. This appears to solvethe pg_subtrans-related context swap storm problem that's been reportedby several people for 8.1. While at it, modify GetSnapshotData to nottake an exclusive lock on ProcArrayLock, as closer analysis shows thatshared lock is always sufficient.Itagaki Takahiro and Tom Lane
1 parentf79f57a commit8fad2e3

File tree

4 files changed

+183
-83
lines changed

4 files changed

+183
-83
lines changed

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

Lines changed: 17 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,7 @@
66
* Copyright (c) 2000-2006, PostgreSQL Global Development Group
77
*
88
* IDENTIFICATION
9-
* $PostgreSQL: pgsql/src/backend/access/transam/varsup.c,v 1.72 2006/07/14 14:52:17 momjian Exp $
9+
* $PostgreSQL: pgsql/src/backend/access/transam/varsup.c,v 1.73 2006/09/03 15:59:38 tgl Exp $
1010
*
1111
*-------------------------------------------------------------------------
1212
*/
@@ -131,17 +131,28 @@ GetNewTransactionId(bool isSubXact)
131131
*/
132132
if (MyProc!=NULL)
133133
{
134+
/*
135+
* Use volatile pointer to prevent code rearrangement; other backends
136+
* could be examining my subxids info concurrently, and we don't
137+
* want them to see an invalid intermediate state, such as
138+
* incrementing nxids before filling the array entry. Note we are
139+
* assuming that TransactionId and int fetch/store are atomic.
140+
*/
141+
volatilePGPROC*myproc=MyProc;
142+
134143
if (!isSubXact)
135-
MyProc->xid=xid;
144+
myproc->xid=xid;
136145
else
137146
{
138-
if (MyProc->subxids.nxids<PGPROC_MAX_CACHED_SUBXIDS)
147+
intnxids=myproc->subxids.nxids;
148+
149+
if (nxids<PGPROC_MAX_CACHED_SUBXIDS)
139150
{
140-
MyProc->subxids.xids[MyProc->subxids.nxids]=xid;
141-
MyProc->subxids.nxids++;
151+
myproc->subxids.xids[nxids]=xid;
152+
myproc->subxids.nxids=nxids+1;
142153
}
143154
else
144-
MyProc->subxids.overflowed= true;
155+
myproc->subxids.overflowed= true;
145156
}
146157
}
147158

‎src/backend/storage/ipc/procarray.c

Lines changed: 59 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -23,7 +23,7 @@
2323
*
2424
*
2525
* IDENTIFICATION
26-
* $PostgreSQL: pgsql/src/backend/storage/ipc/procarray.c,v 1.16 2006/07/30 20:17:11 tgl Exp $
26+
* $PostgreSQL: pgsql/src/backend/storage/ipc/procarray.c,v 1.17 2006/09/03 15:59:38 tgl Exp $
2727
*
2828
*-------------------------------------------------------------------------
2929
*/
@@ -475,9 +475,12 @@ GetOldestXmin(bool allDbs, bool ignoreVacuum)
475475
* This ensures that the set of transactions seen as "running" by the
476476
* current xact will not change after it takes the snapshot.
477477
*
478-
* Note that only top-level XIDs are included in the snapshot.We can
479-
* still apply the xmin and xmax limits to subtransaction XIDs, but we
480-
* need to work a bit harder to see if XIDs in [xmin..xmax) are running.
478+
* All running top-level XIDs are included in the snapshot. We also try
479+
* to include running subtransaction XIDs, but since PGPROC has only a
480+
* limited cache area for subxact XIDs, full information may not be
481+
* available. If we find any overflowed subxid arrays, we have to mark
482+
* the snapshot's subxid data as overflowed, and extra work will need to
483+
* be done to determine what's running (see XidInSnapshot() in tqual.c).
481484
*
482485
* We also update the following backend-global variables:
483486
*TransactionXmin: the oldest xmin of any snapshot in use in the
@@ -499,6 +502,7 @@ GetSnapshotData(Snapshot snapshot, bool serializable)
499502
TransactionIdglobalxmin;
500503
intindex;
501504
intcount=0;
505+
intsubcount=0;
502506

503507
Assert(snapshot!=NULL);
504508

@@ -510,11 +514,12 @@ GetSnapshotData(Snapshot snapshot, bool serializable)
510514
/*
511515
* Allocating space for maxProcs xids is usually overkill; numProcs would
512516
* be sufficient. But it seems better to do the malloc while not holding
513-
* the lock, so we can't look at numProcs.
517+
* the lock, so we can't look at numProcs. Likewise, we allocate much
518+
* more subxip storage than is probably needed.
514519
*
515520
* This does open a possibility for avoiding repeated malloc/free: since
516521
* maxProcs does not change at runtime, we can simply reuse the previous
517-
* xiparray if any. (This relies on the fact that all callers pass
522+
* xiparrays if any. (This relies on the fact that all callers pass
518523
* static SnapshotData structs.)
519524
*/
520525
if (snapshot->xip==NULL)
@@ -528,15 +533,29 @@ GetSnapshotData(Snapshot snapshot, bool serializable)
528533
ereport(ERROR,
529534
(errcode(ERRCODE_OUT_OF_MEMORY),
530535
errmsg("out of memory")));
536+
Assert(snapshot->subxip==NULL);
537+
snapshot->subxip= (TransactionId*)
538+
malloc(arrayP->maxProcs*PGPROC_MAX_CACHED_SUBXIDS*sizeof(TransactionId));
539+
if (snapshot->subxip==NULL)
540+
ereport(ERROR,
541+
(errcode(ERRCODE_OUT_OF_MEMORY),
542+
errmsg("out of memory")));
531543
}
532544

533545
globalxmin=xmin=GetTopTransactionId();
534546

535547
/*
536-
* If we are going to set MyProc->xmin then we'd better get exclusive
537-
* lock; if not, this is a read-only operation so it can be shared.
548+
* It is sufficient to get shared lock on ProcArrayLock, even if we
549+
* are computing a serializable snapshot and therefore will be setting
550+
* MyProc->xmin. This is because any two backends that have overlapping
551+
* shared holds on ProcArrayLock will certainly compute the same xmin
552+
* (since no xact, in particular not the oldest, can exit the set of
553+
* running transactions while we hold ProcArrayLock --- see further
554+
* discussion just below). So it doesn't matter whether another backend
555+
* concurrently doing GetSnapshotData or GetOldestXmin sees our xmin as
556+
* set or not; he'd compute the same xmin for himself either way.
538557
*/
539-
LWLockAcquire(ProcArrayLock,serializable ?LW_EXCLUSIVE :LW_SHARED);
558+
LWLockAcquire(ProcArrayLock,LW_SHARED);
540559

541560
/*--------------------
542561
* Unfortunately, we have to call ReadNewTransactionId() after acquiring
@@ -599,6 +618,35 @@ GetSnapshotData(Snapshot snapshot, bool serializable)
599618
if (TransactionIdIsNormal(xid))
600619
if (TransactionIdPrecedes(xid,globalxmin))
601620
globalxmin=xid;
621+
622+
/*
623+
* Save subtransaction XIDs if possible (if we've already overflowed,
624+
* there's no point). Note that the subxact XIDs must be later than
625+
* their parent, so no need to check them against xmin.
626+
*
627+
* The other backend can add more subxids concurrently, but cannot
628+
* remove any. Hence it's important to fetch nxids just once.
629+
* Should be safe to use memcpy, though. (We needn't worry about
630+
* missing any xids added concurrently, because they must postdate
631+
* xmax.)
632+
*/
633+
if (subcount >=0)
634+
{
635+
if (proc->subxids.overflowed)
636+
subcount=-1;/* overflowed */
637+
else
638+
{
639+
intnxids=proc->subxids.nxids;
640+
641+
if (nxids>0)
642+
{
643+
memcpy(snapshot->subxip+subcount,
644+
proc->subxids.xids,
645+
nxids*sizeof(TransactionId));
646+
subcount+=nxids;
647+
}
648+
}
649+
}
602650
}
603651

604652
if (serializable)
@@ -621,6 +669,7 @@ GetSnapshotData(Snapshot snapshot, bool serializable)
621669
snapshot->xmin=xmin;
622670
snapshot->xmax=xmax;
623671
snapshot->xcnt=count;
672+
snapshot->subxcnt=subcount;
624673

625674
snapshot->curcid=GetCurrentCommandId();
626675

@@ -862,7 +911,7 @@ XidCacheRemoveRunningXids(TransactionId xid, int nxids, TransactionId *xids)
862911
inti,
863912
j;
864913

865-
Assert(!TransactionIdEquals(xid,InvalidTransactionId));
914+
Assert(TransactionIdIsValid(xid));
866915

867916
/*
868917
* We must hold ProcArrayLock exclusively in order to remove transactions

‎src/backend/utils/time/tqual.c

Lines changed: 100 additions & 66 deletions
Original file line numberDiff line numberDiff line change
@@ -32,7 +32,7 @@
3232
* Portions Copyright (c) 1994, Regents of the University of California
3333
*
3434
* IDENTIFICATION
35-
* $PostgreSQL: pgsql/src/backend/utils/time/tqual.c,v 1.95 2006/07/13 17:47:01 momjian Exp $
35+
* $PostgreSQL: pgsql/src/backend/utils/time/tqual.c,v 1.96 2006/09/03 15:59:39 tgl Exp $
3636
*
3737
*-------------------------------------------------------------------------
3838
*/
@@ -72,6 +72,9 @@ TransactionId TransactionXmin = InvalidTransactionId;
7272
TransactionIdRecentXmin=InvalidTransactionId;
7373
TransactionIdRecentGlobalXmin=InvalidTransactionId;
7474

75+
/* local functions */
76+
staticboolXidInSnapshot(TransactionIdxid,Snapshotsnapshot);
77+
7578

7679
/*
7780
* HeapTupleSatisfiesItself
@@ -943,38 +946,9 @@ HeapTupleSatisfiesSnapshot(HeapTupleHeader tuple, Snapshot snapshot,
943946
/*
944947
* By here, the inserting transaction has committed - have to check
945948
* when...
946-
*
947-
* Note that the provided snapshot contains only top-level XIDs, so we
948-
* have to convert a subxact XID to its parent for comparison. However, we
949-
* can make first-pass range checks with the given XID, because a subxact
950-
* with XID < xmin has surely also got a parent with XID < xmin, while one
951-
* with XID >= xmax must belong to a parent that was not yet committed at
952-
* the time of this snapshot.
953949
*/
954-
if (TransactionIdFollowsOrEquals(HeapTupleHeaderGetXmin(tuple),
955-
snapshot->xmin))
956-
{
957-
TransactionIdparentXid;
958-
959-
if (TransactionIdFollowsOrEquals(HeapTupleHeaderGetXmin(tuple),
960-
snapshot->xmax))
961-
return false;
962-
963-
parentXid=SubTransGetTopmostTransaction(HeapTupleHeaderGetXmin(tuple));
964-
965-
if (TransactionIdFollowsOrEquals(parentXid,snapshot->xmin))
966-
{
967-
uint32i;
968-
969-
/* no point in checking parentXid against xmax here */
970-
971-
for (i=0;i<snapshot->xcnt;i++)
972-
{
973-
if (TransactionIdEquals(parentXid,snapshot->xip[i]))
974-
return false;
975-
}
976-
}
977-
}
950+
if (XidInSnapshot(HeapTupleHeaderGetXmin(tuple),snapshot))
951+
return false;/* treat as still in progress */
978952

979953
if (tuple->t_infomask&HEAP_XMAX_INVALID)/* xid invalid or aborted */
980954
return true;
@@ -1017,40 +991,11 @@ HeapTupleSatisfiesSnapshot(HeapTupleHeader tuple, Snapshot snapshot,
1017991

1018992
/*
1019993
* OK, the deleting transaction committed too ... but when?
1020-
*
1021-
* See notes for the similar tests on tuple xmin, above.
1022994
*/
1023-
if (TransactionIdFollowsOrEquals(HeapTupleHeaderGetXmax(tuple),
1024-
snapshot->xmin))
1025-
{
1026-
TransactionIdparentXid;
995+
if (XidInSnapshot(HeapTupleHeaderGetXmax(tuple),snapshot))
996+
return true;/* treat as still in progress */
1027997

1028-
if (TransactionIdFollowsOrEquals(HeapTupleHeaderGetXmax(tuple),
1029-
snapshot->xmax))
1030-
return true;
1031-
1032-
parentXid=SubTransGetTopmostTransaction(HeapTupleHeaderGetXmax(tuple));
1033-
1034-
if (TransactionIdFollowsOrEquals(parentXid,snapshot->xmin))
1035-
{
1036-
uint32i;
1037-
1038-
/* no point in checking parentXid against xmax here */
1039-
1040-
for (i=0;i<snapshot->xcnt;i++)
1041-
{
1042-
if (TransactionIdEquals(parentXid,snapshot->xip[i]))
1043-
return true;
1044-
}
1045-
}
1046-
}
1047-
1048-
/* This is to be used only for disaster recovery and requires serious analysis. */
1049-
#ifndefMAKE_EXPIRED_TUPLES_VISIBLE
1050998
return false;
1051-
#else
1052-
return true;
1053-
#endif
1054999
}
10551000

10561001

@@ -1299,11 +1244,19 @@ Snapshot
12991244
CopySnapshot(Snapshotsnapshot)
13001245
{
13011246
Snapshotnewsnap;
1247+
Sizesubxipoff;
1248+
Sizesize;
13021249

1303-
/* We allocate any XID array needed in the same palloc block. */
1304-
newsnap= (Snapshot)palloc(sizeof(SnapshotData)+
1305-
snapshot->xcnt*sizeof(TransactionId));
1250+
/* We allocate any XID arrays needed in the same palloc block. */
1251+
size=subxipoff=sizeof(SnapshotData)+
1252+
snapshot->xcnt*sizeof(TransactionId);
1253+
if (snapshot->subxcnt>0)
1254+
size+=snapshot->subxcnt*sizeof(TransactionId);
1255+
1256+
newsnap= (Snapshot)palloc(size);
13061257
memcpy(newsnap,snapshot,sizeof(SnapshotData));
1258+
1259+
/* setup XID array */
13071260
if (snapshot->xcnt>0)
13081261
{
13091262
newsnap->xip= (TransactionId*) (newsnap+1);
@@ -1313,6 +1266,16 @@ CopySnapshot(Snapshot snapshot)
13131266
else
13141267
newsnap->xip=NULL;
13151268

1269+
/* setup subXID array */
1270+
if (snapshot->subxcnt>0)
1271+
{
1272+
newsnap->subxip= (TransactionId*) ((char*)newsnap+subxipoff);
1273+
memcpy(newsnap->subxip,snapshot->subxip,
1274+
snapshot->subxcnt*sizeof(TransactionId));
1275+
}
1276+
else
1277+
newsnap->subxip=NULL;
1278+
13161279
returnnewsnap;
13171280
}
13181281

@@ -1347,3 +1310,74 @@ FreeXactSnapshot(void)
13471310
LatestSnapshot=NULL;
13481311
ActiveSnapshot=NULL;/* just for cleanliness */
13491312
}
1313+
1314+
/*
1315+
* XidInSnapshot
1316+
*Is the given XID still-in-progress according to the snapshot?
1317+
*
1318+
* Note: GetSnapshotData never stores either top xid or subxids of our own
1319+
* backend into a snapshot, so these xids will not be reported as "running"
1320+
* by this function. This is OK for current uses, because we actually only
1321+
* apply this for known-committed XIDs.
1322+
*/
1323+
staticbool
1324+
XidInSnapshot(TransactionIdxid,Snapshotsnapshot)
1325+
{
1326+
uint32i;
1327+
1328+
/*
1329+
* Make a quick range check to eliminate most XIDs without looking at the
1330+
* xip arrays. Note that this is OK even if we convert a subxact XID to
1331+
* its parent below, because a subxact with XID < xmin has surely also got
1332+
* a parent with XID < xmin, while one with XID >= xmax must belong to a
1333+
* parent that was not yet committed at the time of this snapshot.
1334+
*/
1335+
1336+
/* Any xid < xmin is not in-progress */
1337+
if (TransactionIdPrecedes(xid,snapshot->xmin))
1338+
return false;
1339+
/* Any xid >= xmax is in-progress */
1340+
if (TransactionIdFollowsOrEquals(xid,snapshot->xmax))
1341+
return true;
1342+
1343+
/*
1344+
* If the snapshot contains full subxact data, the fastest way to check
1345+
* things is just to compare the given XID against both subxact XIDs and
1346+
* top-level XIDs. If the snapshot overflowed, we have to use pg_subtrans
1347+
* to convert a subxact XID to its parent XID, but then we need only look
1348+
* at top-level XIDs not subxacts.
1349+
*/
1350+
if (snapshot->subxcnt >=0)
1351+
{
1352+
/* full data, so search subxip */
1353+
int32j;
1354+
1355+
for (j=0;j<snapshot->subxcnt;j++)
1356+
{
1357+
if (TransactionIdEquals(xid,snapshot->subxip[j]))
1358+
return true;
1359+
}
1360+
1361+
/* not there, fall through to search xip[] */
1362+
}
1363+
else
1364+
{
1365+
/* overflowed, so convert xid to top-level */
1366+
xid=SubTransGetTopmostTransaction(xid);
1367+
1368+
/*
1369+
* If xid was indeed a subxact, we might now have an xid < xmin,
1370+
* so recheck to avoid an array scan. No point in rechecking xmax.
1371+
*/
1372+
if (TransactionIdPrecedes(xid,snapshot->xmin))
1373+
return false;
1374+
}
1375+
1376+
for (i=0;i<snapshot->xcnt;i++)
1377+
{
1378+
if (TransactionIdEquals(xid,snapshot->xip[i]))
1379+
return true;
1380+
}
1381+
1382+
return false;
1383+
}

0 commit comments

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