mirror of https://github.com/postgres/postgres
communication structure, and make it its own module with its own lock. This should reduce contention at least a little, and it definitely makes the code seem cleaner. Per my recent proposal.REL8_1_STABLE
Tom Lane
21 years ago
parent
6910032a56
commit
ee3b71f6bc
@ -0,0 +1,787 @@ |
||||
/*-------------------------------------------------------------------------
|
||||
* |
||||
* procarray.c |
||||
* POSTGRES process array code. |
||||
* |
||||
* |
||||
* This module maintains an unsorted array of the PGPROC structures for all |
||||
* active backends. Although there are several uses for this, the principal |
||||
* one is as a means of determining the set of currently running transactions. |
||||
* |
||||
* Because of various subtle race conditions it is critical that a backend |
||||
* hold the correct locks while setting or clearing its MyProc->xid field. |
||||
* See notes in GetSnapshotData. |
||||
*
|
||||
* |
||||
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group |
||||
* Portions Copyright (c) 1994, Regents of the University of California |
||||
* |
||||
* |
||||
* IDENTIFICATION |
||||
* $PostgreSQL: pgsql/src/backend/storage/ipc/procarray.c,v 1.1 2005/05/19 21:35:46 tgl Exp $ |
||||
* |
||||
*------------------------------------------------------------------------- |
||||
*/ |
||||
#include "postgres.h" |
||||
|
||||
#include "access/subtrans.h" |
||||
#include "miscadmin.h" |
||||
#include "storage/proc.h" |
||||
#include "storage/procarray.h" |
||||
#include "utils/tqual.h" |
||||
|
||||
|
||||
/* Our shared memory area */ |
||||
typedef struct ProcArrayStruct |
||||
{ |
||||
int numProcs; /* number of valid procs entries */ |
||||
int maxProcs; /* allocated size of procs array */ |
||||
|
||||
/*
|
||||
* We declare procs[] as 1 entry because C wants a fixed-size array, |
||||
* but actually it is maxProcs entries long. |
||||
*/ |
||||
PGPROC *procs[1]; /* VARIABLE LENGTH ARRAY */ |
||||
} ProcArrayStruct; |
||||
|
||||
static ProcArrayStruct *procArray; |
||||
|
||||
|
||||
#ifdef XIDCACHE_DEBUG |
||||
|
||||
/* counters for XidCache measurement */ |
||||
static long xc_by_recent_xmin = 0; |
||||
static long xc_by_main_xid = 0; |
||||
static long xc_by_child_xid = 0; |
||||
static long xc_slow_answer = 0; |
||||
|
||||
#define xc_by_recent_xmin_inc() (xc_by_recent_xmin++) |
||||
#define xc_by_main_xid_inc() (xc_by_main_xid++) |
||||
#define xc_by_child_xid_inc() (xc_by_child_xid++) |
||||
#define xc_slow_answer_inc() (xc_slow_answer++) |
||||
|
||||
static void DisplayXidCache(void); |
||||
|
||||
#else /* !XIDCACHE_DEBUG */ |
||||
|
||||
#define xc_by_recent_xmin_inc() ((void) 0) |
||||
#define xc_by_main_xid_inc() ((void) 0) |
||||
#define xc_by_child_xid_inc() ((void) 0) |
||||
#define xc_slow_answer_inc() ((void) 0) |
||||
|
||||
#endif /* XIDCACHE_DEBUG */ |
||||
|
||||
|
||||
/*
|
||||
* Report shared-memory space needed by CreateSharedProcArray. |
||||
*/ |
||||
int |
||||
ProcArrayShmemSize(int maxBackends) |
||||
{ |
||||
/* sizeof(ProcArrayStruct) includes the first array element */ |
||||
return MAXALIGN(sizeof(ProcArrayStruct) + |
||||
(maxBackends - 1) * sizeof(PGPROC *)); |
||||
} |
||||
|
||||
/*
|
||||
* Initialize the shared PGPROC array during postmaster startup. |
||||
*/ |
||||
void |
||||
CreateSharedProcArray(int maxBackends) |
||||
{ |
||||
bool found; |
||||
|
||||
/* Create or attach to the ProcArray shared structure */ |
||||
procArray = (ProcArrayStruct *) |
||||
ShmemInitStruct("Proc Array", ProcArrayShmemSize(maxBackends), |
||||
&found); |
||||
|
||||
if (!found) |
||||
{ |
||||
/*
|
||||
* We're the first - initialize. |
||||
*/ |
||||
procArray->numProcs = 0; |
||||
procArray->maxProcs = maxBackends; |
||||
} |
||||
} |
||||
|
||||
/*
|
||||
* Add my own PGPROC (found in the global MyProc) to the shared array. |
||||
* |
||||
* This must be called during backend startup, after fully initializing |
||||
* the contents of MyProc. |
||||
*/ |
||||
void |
||||
ProcArrayAddMyself(void) |
||||
{ |
||||
ProcArrayStruct *arrayP = procArray; |
||||
|
||||
LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE); |
||||
|
||||
if (arrayP->numProcs >= arrayP->maxProcs) |
||||
{ |
||||
/*
|
||||
* Ooops, no room. (This really shouldn't happen, since there is |
||||
* a fixed supply of PGPROC structs too, and so we should have |
||||
* failed earlier.) |
||||
*/ |
||||
LWLockRelease(ProcArrayLock); |
||||
ereport(FATAL, |
||||
(errcode(ERRCODE_TOO_MANY_CONNECTIONS), |
||||
errmsg("sorry, too many clients already"))); |
||||
} |
||||
|
||||
arrayP->procs[arrayP->numProcs] = MyProc; |
||||
arrayP->numProcs++; |
||||
|
||||
LWLockRelease(ProcArrayLock); |
||||
} |
||||
|
||||
/*
|
||||
* Remove my own PGPROC (found in the global MyProc) from the shared array. |
||||
* |
||||
* This must be called during backend shutdown. |
||||
*/ |
||||
void |
||||
ProcArrayRemoveMyself(void) |
||||
{ |
||||
ProcArrayStruct *arrayP = procArray; |
||||
int index; |
||||
|
||||
#ifdef XIDCACHE_DEBUG |
||||
DisplayXidCache(); |
||||
#endif |
||||
|
||||
LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE); |
||||
|
||||
for (index = 0; index < arrayP->numProcs; index++) |
||||
{ |
||||
if (arrayP->procs[index] == MyProc) |
||||
{ |
||||
arrayP->procs[index] = arrayP->procs[arrayP->numProcs - 1]; |
||||
arrayP->numProcs--; |
||||
LWLockRelease(ProcArrayLock); |
||||
return; |
||||
} |
||||
} |
||||
|
||||
/* Ooops */ |
||||
LWLockRelease(ProcArrayLock); |
||||
|
||||
elog(LOG, "failed to find my own proc %p in ProcArray", MyProc); |
||||
} |
||||
|
||||
|
||||
/*
|
||||
* TransactionIdIsInProgress -- is given transaction running in some backend |
||||
* |
||||
* There are three possibilities for finding a running transaction: |
||||
* |
||||
* 1. the given Xid is a main transaction Id. We will find this out cheaply |
||||
* by looking at the PGPROC struct for each backend. |
||||
* |
||||
* 2. the given Xid is one of the cached subxact Xids in the PGPROC array. |
||||
* We can find this out cheaply too. |
||||
* |
||||
* 3. Search the SubTrans tree to find the Xid's topmost parent, and then |
||||
* see if that is running according to PGPROC. This is the slowest, but |
||||
* sadly it has to be done always if the other two failed, unless we see |
||||
* that the cached subxact sets are complete (none have overflowed). |
||||
* |
||||
* ProcArrayLock has to be held while we do 1 and 2. If we save the top Xids |
||||
* while doing 1, we can release the ProcArrayLock while we do 3. This buys |
||||
* back some concurrency (we can't retrieve the main Xids from PGPROC again |
||||
* anyway; see GetNewTransactionId). |
||||
*/ |
||||
bool |
||||
TransactionIdIsInProgress(TransactionId xid) |
||||
{ |
||||
bool result = false; |
||||
ProcArrayStruct *arrayP = procArray; |
||||
int i, |
||||
j; |
||||
int nxids = 0; |
||||
TransactionId *xids; |
||||
TransactionId topxid; |
||||
bool locked; |
||||
|
||||
/*
|
||||
* Don't bother checking a transaction older than RecentXmin; it |
||||
* could not possibly still be running. |
||||
*/ |
||||
if (TransactionIdPrecedes(xid, RecentXmin)) |
||||
{ |
||||
xc_by_recent_xmin_inc(); |
||||
return false; |
||||
} |
||||
|
||||
/* Get workspace to remember main XIDs in */ |
||||
xids = (TransactionId *) palloc(sizeof(TransactionId) * arrayP->maxProcs); |
||||
|
||||
LWLockAcquire(ProcArrayLock, LW_SHARED); |
||||
locked = true; |
||||
|
||||
for (i = 0; i < arrayP->numProcs; i++) |
||||
{ |
||||
PGPROC *proc = arrayP->procs[i]; |
||||
|
||||
/* Fetch xid just once - see GetNewTransactionId */ |
||||
TransactionId pxid = proc->xid; |
||||
|
||||
if (!TransactionIdIsValid(pxid)) |
||||
continue; |
||||
|
||||
/*
|
||||
* Step 1: check the main Xid |
||||
*/ |
||||
if (TransactionIdEquals(pxid, xid)) |
||||
{ |
||||
xc_by_main_xid_inc(); |
||||
result = true; |
||||
goto result_known; |
||||
} |
||||
|
||||
/*
|
||||
* We can ignore main Xids that are younger than the target |
||||
* Xid, since the target could not possibly be their child. |
||||
*/ |
||||
if (TransactionIdPrecedes(xid, pxid)) |
||||
continue; |
||||
|
||||
/*
|
||||
* Step 2: check the cached child-Xids arrays |
||||
*/ |
||||
for (j = proc->subxids.nxids - 1; j >= 0; j--) |
||||
{ |
||||
/* Fetch xid just once - see GetNewTransactionId */ |
||||
TransactionId cxid = proc->subxids.xids[j]; |
||||
|
||||
if (TransactionIdEquals(cxid, xid)) |
||||
{ |
||||
xc_by_child_xid_inc(); |
||||
result = true; |
||||
goto result_known; |
||||
} |
||||
} |
||||
|
||||
/*
|
||||
* Save the main Xid for step 3. We only need to remember |
||||
* main Xids that have uncached children. (Note: there is no |
||||
* race condition here because the overflowed flag cannot be |
||||
* cleared, only set, while we hold ProcArrayLock. So we can't |
||||
* miss an Xid that we need to worry about.) |
||||
*/ |
||||
if (proc->subxids.overflowed) |
||||
xids[nxids++] = pxid; |
||||
} |
||||
|
||||
LWLockRelease(ProcArrayLock); |
||||
locked = false; |
||||
|
||||
/*
|
||||
* If none of the relevant caches overflowed, we know the Xid is not |
||||
* running without looking at pg_subtrans. |
||||
*/ |
||||
if (nxids == 0) |
||||
goto result_known; |
||||
|
||||
/*
|
||||
* Step 3: have to check pg_subtrans. |
||||
* |
||||
* At this point, we know it's either a subtransaction of one of the Xids |
||||
* in xids[], or it's not running. If it's an already-failed |
||||
* subtransaction, we want to say "not running" even though its parent |
||||
* may still be running. So first, check pg_clog to see if it's been |
||||
* aborted. |
||||
*/ |
||||
xc_slow_answer_inc(); |
||||
|
||||
if (TransactionIdDidAbort(xid)) |
||||
goto result_known; |
||||
|
||||
/*
|
||||
* It isn't aborted, so check whether the transaction tree it belongs |
||||
* to is still running (or, more precisely, whether it was running |
||||
* when this routine started -- note that we already released |
||||
* ProcArrayLock). |
||||
*/ |
||||
topxid = SubTransGetTopmostTransaction(xid); |
||||
Assert(TransactionIdIsValid(topxid)); |
||||
if (!TransactionIdEquals(topxid, xid)) |
||||
{ |
||||
for (i = 0; i < nxids; i++) |
||||
{ |
||||
if (TransactionIdEquals(xids[i], topxid)) |
||||
{ |
||||
result = true; |
||||
break; |
||||
} |
||||
} |
||||
} |
||||
|
||||
result_known: |
||||
if (locked) |
||||
LWLockRelease(ProcArrayLock); |
||||
|
||||
pfree(xids); |
||||
|
||||
return result; |
||||
} |
||||
|
||||
/*
|
||||
* GetOldestXmin -- returns oldest transaction that was running |
||||
* when any current transaction was started. |
||||
* |
||||
* If allDbs is TRUE then all backends are considered; if allDbs is FALSE |
||||
* then only backends running in my own database are considered. |
||||
* |
||||
* This is used by VACUUM to decide which deleted tuples must be preserved |
||||
* in a table. allDbs = TRUE is needed for shared relations, but allDbs = |
||||
* FALSE is sufficient for non-shared relations, since only backends in my |
||||
* own database could ever see the tuples in them. |
||||
* |
||||
* This is also used to determine where to truncate pg_subtrans. allDbs |
||||
* must be TRUE for that case. |
||||
* |
||||
* Note: we include the currently running xids in the set of considered xids. |
||||
* This ensures that if a just-started xact has not yet set its snapshot, |
||||
* when it does set the snapshot it cannot set xmin less than what we compute. |
||||
*/ |
||||
TransactionId |
||||
GetOldestXmin(bool allDbs) |
||||
{ |
||||
ProcArrayStruct *arrayP = procArray; |
||||
TransactionId result; |
||||
int index; |
||||
|
||||
/*
|
||||
* Normally we start the min() calculation with our own XID. But if |
||||
* called by checkpointer, we will not be inside a transaction, so use |
||||
* next XID as starting point for min() calculation. (Note that if |
||||
* there are no xacts running at all, that will be the subtrans |
||||
* truncation point!) |
||||
*/ |
||||
if (IsTransactionState()) |
||||
result = GetTopTransactionId(); |
||||
else |
||||
result = ReadNewTransactionId(); |
||||
|
||||
LWLockAcquire(ProcArrayLock, LW_SHARED); |
||||
|
||||
for (index = 0; index < arrayP->numProcs; index++) |
||||
{ |
||||
PGPROC *proc = arrayP->procs[index]; |
||||
|
||||
if (allDbs || proc->databaseId == MyDatabaseId) |
||||
{ |
||||
/* Fetch xid just once - see GetNewTransactionId */ |
||||
TransactionId xid = proc->xid; |
||||
|
||||
if (TransactionIdIsNormal(xid)) |
||||
{ |
||||
if (TransactionIdPrecedes(xid, result)) |
||||
result = xid; |
||||
xid = proc->xmin; |
||||
if (TransactionIdIsNormal(xid)) |
||||
if (TransactionIdPrecedes(xid, result)) |
||||
result = xid; |
||||
} |
||||
} |
||||
} |
||||
|
||||
LWLockRelease(ProcArrayLock); |
||||
|
||||
return result; |
||||
} |
||||
|
||||
/*----------
|
||||
* GetSnapshotData -- returns information about running transactions. |
||||
* |
||||
* The returned snapshot includes xmin (lowest still-running xact ID), |
||||
* xmax (next xact ID to be assigned), and a list of running xact IDs |
||||
* in the range xmin <= xid < xmax. It is used as follows: |
||||
* All xact IDs < xmin are considered finished. |
||||
* All xact IDs >= xmax are considered still running. |
||||
* For an xact ID xmin <= xid < xmax, consult list to see whether |
||||
* it is considered running or not. |
||||
* This ensures that the set of transactions seen as "running" by the |
||||
* current xact will not change after it takes the snapshot. |
||||
* |
||||
* Note that only top-level XIDs are included in the snapshot. We can |
||||
* still apply the xmin and xmax limits to subtransaction XIDs, but we |
||||
* need to work a bit harder to see if XIDs in [xmin..xmax) are running. |
||||
* |
||||
* We also update the following backend-global variables: |
||||
* TransactionXmin: the oldest xmin of any snapshot in use in the |
||||
* current transaction (this is the same as MyProc->xmin). This |
||||
* is just the xmin computed for the first, serializable snapshot. |
||||
* RecentXmin: the xmin computed for the most recent snapshot. XIDs |
||||
* older than this are known not running any more. |
||||
* RecentGlobalXmin: the global xmin (oldest TransactionXmin across all |
||||
* running transactions). This is the same computation done by |
||||
* GetOldestXmin(TRUE). |
||||
*---------- |
||||
*/ |
||||
Snapshot |
||||
GetSnapshotData(Snapshot snapshot, bool serializable) |
||||
{ |
||||
ProcArrayStruct *arrayP = procArray; |
||||
TransactionId xmin; |
||||
TransactionId xmax; |
||||
TransactionId globalxmin; |
||||
int index; |
||||
int count = 0; |
||||
|
||||
Assert(snapshot != NULL); |
||||
|
||||
/* Serializable snapshot must be computed before any other... */ |
||||
Assert(serializable ? |
||||
!TransactionIdIsValid(MyProc->xmin) : |
||||
TransactionIdIsValid(MyProc->xmin)); |
||||
|
||||
/*
|
||||
* Allocating space for MaxBackends xids is usually overkill; |
||||
* lastBackend would be sufficient. But it seems better to do the |
||||
* malloc while not holding the lock, so we can't look at lastBackend. |
||||
* |
||||
* This does open a possibility for avoiding repeated malloc/free: since |
||||
* MaxBackends does not change at runtime, we can simply reuse the |
||||
* previous xip array if any. (This relies on the fact that all |
||||
* callers pass static SnapshotData structs.) |
||||
*/ |
||||
if (snapshot->xip == NULL) |
||||
{ |
||||
/*
|
||||
* First call for this snapshot |
||||
*/ |
||||
snapshot->xip = (TransactionId *) |
||||
malloc(MaxBackends * sizeof(TransactionId)); |
||||
if (snapshot->xip == NULL) |
||||
ereport(ERROR, |
||||
(errcode(ERRCODE_OUT_OF_MEMORY), |
||||
errmsg("out of memory"))); |
||||
} |
||||
|
||||
globalxmin = xmin = GetTopTransactionId(); |
||||
|
||||
/*
|
||||
* If we are going to set MyProc->xmin then we'd better get exclusive |
||||
* lock; if not, this is a read-only operation so it can be shared. |
||||
*/ |
||||
LWLockAcquire(ProcArrayLock, serializable ? LW_EXCLUSIVE : LW_SHARED); |
||||
|
||||
/*--------------------
|
||||
* Unfortunately, we have to call ReadNewTransactionId() after acquiring |
||||
* ProcArrayLock above. It's not good because ReadNewTransactionId() does |
||||
* LWLockAcquire(XidGenLock), but *necessary*. We need to be sure that |
||||
* no transactions exit the set of currently-running transactions |
||||
* between the time we fetch xmax and the time we finish building our |
||||
* snapshot. Otherwise we could have a situation like this: |
||||
* |
||||
* 1. Tx Old is running (in Read Committed mode). |
||||
* 2. Tx S reads new transaction ID into xmax, then |
||||
* is swapped out before acquiring ProcArrayLock. |
||||
* 3. Tx New gets new transaction ID (>= S' xmax), |
||||
* makes changes and commits. |
||||
* 4. Tx Old changes some row R changed by Tx New and commits. |
||||
* 5. Tx S finishes getting its snapshot data. It sees Tx Old as |
||||
* done, but sees Tx New as still running (since New >= xmax). |
||||
* |
||||
* Now S will see R changed by both Tx Old and Tx New, *but* does not |
||||
* see other changes made by Tx New. If S is supposed to be in |
||||
* Serializable mode, this is wrong. |
||||
* |
||||
* By locking ProcArrayLock before we read xmax, we ensure that TX Old |
||||
* cannot exit the set of running transactions seen by Tx S. Therefore |
||||
* both Old and New will be seen as still running => no inconsistency. |
||||
*-------------------- |
||||
*/ |
||||
|
||||
xmax = ReadNewTransactionId(); |
||||
|
||||
for (index = 0; index < arrayP->numProcs; index++) |
||||
{ |
||||
PGPROC *proc = arrayP->procs[index]; |
||||
|
||||
/* Fetch xid just once - see GetNewTransactionId */ |
||||
TransactionId xid = proc->xid; |
||||
|
||||
/*
|
||||
* Ignore my own proc (dealt with my xid above), procs not |
||||
* running a transaction, and xacts started since we read the |
||||
* next transaction ID. There's no need to store XIDs above |
||||
* what we got from ReadNewTransactionId, since we'll treat |
||||
* them as running anyway. We also assume that such xacts |
||||
* can't compute an xmin older than ours, so they needn't be |
||||
* considered in computing globalxmin. |
||||
*/ |
||||
if (proc == MyProc || |
||||
!TransactionIdIsNormal(xid) || |
||||
TransactionIdFollowsOrEquals(xid, xmax)) |
||||
continue; |
||||
|
||||
if (TransactionIdPrecedes(xid, xmin)) |
||||
xmin = xid; |
||||
snapshot->xip[count] = xid; |
||||
count++; |
||||
|
||||
/* Update globalxmin to be the smallest valid xmin */ |
||||
xid = proc->xmin; |
||||
if (TransactionIdIsNormal(xid)) |
||||
if (TransactionIdPrecedes(xid, globalxmin)) |
||||
globalxmin = xid; |
||||
} |
||||
|
||||
if (serializable) |
||||
MyProc->xmin = TransactionXmin = xmin; |
||||
|
||||
LWLockRelease(ProcArrayLock); |
||||
|
||||
/*
|
||||
* Update globalxmin to include actual process xids. This is a |
||||
* slightly different way of computing it than GetOldestXmin uses, but |
||||
* should give the same result. |
||||
*/ |
||||
if (TransactionIdPrecedes(xmin, globalxmin)) |
||||
globalxmin = xmin; |
||||
|
||||
/* Update global variables too */ |
||||
RecentGlobalXmin = globalxmin; |
||||
RecentXmin = xmin; |
||||
|
||||
snapshot->xmin = xmin; |
||||
snapshot->xmax = xmax; |
||||
snapshot->xcnt = count; |
||||
|
||||
snapshot->curcid = GetCurrentCommandId(); |
||||
|
||||
return snapshot; |
||||
} |
||||
|
||||
/*
|
||||
* DatabaseHasActiveBackends -- are there any backends running in the given DB |
||||
* |
||||
* If 'ignoreMyself' is TRUE, ignore this particular backend while checking |
||||
* for backends in the target database. |
||||
* |
||||
* This function is used to interlock DROP DATABASE against there being |
||||
* any active backends in the target DB --- dropping the DB while active |
||||
* backends remain would be a Bad Thing. Note that we cannot detect here |
||||
* the possibility of a newly-started backend that is trying to connect |
||||
* to the doomed database, so additional interlocking is needed during |
||||
* backend startup. |
||||
*/ |
||||
bool |
||||
DatabaseHasActiveBackends(Oid databaseId, bool ignoreMyself) |
||||
{ |
||||
bool result = false; |
||||
ProcArrayStruct *arrayP = procArray; |
||||
int index; |
||||
|
||||
LWLockAcquire(ProcArrayLock, LW_SHARED); |
||||
|
||||
for (index = 0; index < arrayP->numProcs; index++) |
||||
{ |
||||
PGPROC *proc = arrayP->procs[index]; |
||||
|
||||
if (proc->databaseId == databaseId) |
||||
{ |
||||
if (ignoreMyself && proc == MyProc) |
||||
continue; |
||||
|
||||
result = true; |
||||
break; |
||||
} |
||||
} |
||||
|
||||
LWLockRelease(ProcArrayLock); |
||||
|
||||
return result; |
||||
} |
||||
|
||||
/*
|
||||
* BackendPidGetProc -- get a backend's PGPROC given its PID |
||||
*/ |
||||
struct PGPROC * |
||||
BackendPidGetProc(int pid) |
||||
{ |
||||
PGPROC *result = NULL; |
||||
ProcArrayStruct *arrayP = procArray; |
||||
int index; |
||||
|
||||
LWLockAcquire(ProcArrayLock, LW_SHARED); |
||||
|
||||
for (index = 0; index < arrayP->numProcs; index++) |
||||
{ |
||||
PGPROC *proc = arrayP->procs[index]; |
||||
|
||||
if (proc->pid == pid) |
||||
{ |
||||
result = proc; |
||||
break; |
||||
} |
||||
} |
||||
|
||||
LWLockRelease(ProcArrayLock); |
||||
|
||||
return result; |
||||
} |
||||
|
||||
/*
|
||||
* IsBackendPid -- is a given pid a running backend |
||||
*/ |
||||
bool |
||||
IsBackendPid(int pid) |
||||
{ |
||||
return (BackendPidGetProc(pid) != NULL); |
||||
} |
||||
|
||||
/*
|
||||
* CountActiveBackends --- count backends (other than myself) that are in |
||||
* active transactions. This is used as a heuristic to decide if |
||||
* a pre-XLOG-flush delay is worthwhile during commit. |
||||
* |
||||
* An active transaction is something that has written at least one XLOG |
||||
* record; read-only transactions don't count. Also, do not count backends |
||||
* that are blocked waiting for locks, since they are not going to get to |
||||
* run until someone else commits. |
||||
*/ |
||||
int |
||||
CountActiveBackends(void) |
||||
{ |
||||
ProcArrayStruct *arrayP = procArray; |
||||
int count = 0; |
||||
int index; |
||||
|
||||
/*
|
||||
* Note: for speed, we don't acquire ProcArrayLock. This is a little bit |
||||
* bogus, but since we are only testing xrecoff for zero or nonzero, |
||||
* it should be OK. The result is only used for heuristic purposes |
||||
* anyway... |
||||
*/ |
||||
for (index = 0; index < arrayP->numProcs; index++) |
||||
{ |
||||
PGPROC *proc = arrayP->procs[index]; |
||||
|
||||
if (proc == MyProc) |
||||
continue; /* do not count myself */ |
||||
if (proc->logRec.xrecoff == 0) |
||||
continue; /* do not count if not in a transaction */ |
||||
if (proc->waitLock != NULL) |
||||
continue; /* do not count if blocked on a lock */ |
||||
count++; |
||||
} |
||||
|
||||
return count; |
||||
} |
||||
|
||||
/*
|
||||
* CountEmptyBackendSlots - count empty slots in backend process table |
||||
* |
||||
* Acquiring the lock here is almost certainly overkill, but just in |
||||
* case fetching an int is not atomic on your machine ... |
||||
*/ |
||||
int |
||||
CountEmptyBackendSlots(void) |
||||
{ |
||||
int count; |
||||
|
||||
LWLockAcquire(ProcArrayLock, LW_SHARED); |
||||
|
||||
count = procArray->maxProcs - procArray->numProcs; |
||||
|
||||
LWLockRelease(ProcArrayLock); |
||||
|
||||
return count; |
||||
} |
||||
|
||||
#define XidCacheRemove(i) \ |
||||
do { \
|
||||
MyProc->subxids.xids[i] = MyProc->subxids.xids[MyProc->subxids.nxids - 1]; \
|
||||
MyProc->subxids.nxids--; \
|
||||
} while (0) |
||||
|
||||
/*
|
||||
* XidCacheRemoveRunningXids |
||||
* |
||||
* Remove a bunch of TransactionIds from the list of known-running |
||||
* subtransactions for my backend. Both the specified xid and those in |
||||
* the xids[] array (of length nxids) are removed from the subxids cache. |
||||
*/ |
||||
void |
||||
XidCacheRemoveRunningXids(TransactionId xid, int nxids, TransactionId *xids) |
||||
{ |
||||
int i, |
||||
j; |
||||
|
||||
Assert(!TransactionIdEquals(xid, InvalidTransactionId)); |
||||
|
||||
/*
|
||||
* We must hold ProcArrayLock exclusively in order to remove transactions |
||||
* from the PGPROC array. (See notes in GetSnapshotData.) It's |
||||
* possible this could be relaxed since we know this routine is only |
||||
* used to abort subtransactions, but pending closer analysis we'd |
||||
* best be conservative. |
||||
*/ |
||||
LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE); |
||||
|
||||
/*
|
||||
* Under normal circumstances xid and xids[] will be in increasing |
||||
* order, as will be the entries in subxids. Scan backwards to avoid |
||||
* O(N^2) behavior when removing a lot of xids. |
||||
*/ |
||||
for (i = nxids - 1; i >= 0; i--) |
||||
{ |
||||
TransactionId anxid = xids[i]; |
||||
|
||||
for (j = MyProc->subxids.nxids - 1; j >= 0; j--) |
||||
{ |
||||
if (TransactionIdEquals(MyProc->subxids.xids[j], anxid)) |
||||
{ |
||||
XidCacheRemove(j); |
||||
break; |
||||
} |
||||
} |
||||
/*
|
||||
* Ordinarily we should have found it, unless the cache has overflowed. |
||||
* However it's also possible for this routine to be invoked multiple |
||||
* times for the same subtransaction, in case of an error during |
||||
* AbortSubTransaction. So instead of Assert, emit a debug warning. |
||||
*/ |
||||
if (j < 0 && !MyProc->subxids.overflowed) |
||||
elog(WARNING, "did not find subXID %u in MyProc", anxid); |
||||
} |
||||
|
||||
for (j = MyProc->subxids.nxids - 1; j >= 0; j--) |
||||
{ |
||||
if (TransactionIdEquals(MyProc->subxids.xids[j], xid)) |
||||
{ |
||||
XidCacheRemove(j); |
||||
break; |
||||
} |
||||
} |
||||
/* Ordinarily we should have found it, unless the cache has overflowed */ |
||||
if (j < 0 && !MyProc->subxids.overflowed) |
||||
elog(WARNING, "did not find subXID %u in MyProc", xid); |
||||
|
||||
LWLockRelease(ProcArrayLock); |
||||
} |
||||
|
||||
#ifdef XIDCACHE_DEBUG |
||||
|
||||
/*
|
||||
* Print stats about effectiveness of XID cache |
||||
*/ |
||||
static void |
||||
DisplayXidCache(void) |
||||
{ |
||||
fprintf(stderr, |
||||
"XidCache: xmin: %ld, mainxid: %ld, childxid: %ld, slow: %ld\n", |
||||
xc_by_recent_xmin, |
||||
xc_by_main_xid, |
||||
xc_by_child_xid, |
||||
xc_slow_answer); |
||||
} |
||||
|
||||
#endif /* XIDCACHE_DEBUG */ |
||||
@ -0,0 +1,36 @@ |
||||
/*-------------------------------------------------------------------------
|
||||
* |
||||
* procarray.h |
||||
* POSTGRES process array definitions. |
||||
* |
||||
* |
||||
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group |
||||
* Portions Copyright (c) 1994, Regents of the University of California |
||||
* |
||||
* $PostgreSQL: pgsql/src/include/storage/procarray.h,v 1.1 2005/05/19 21:35:47 tgl Exp $ |
||||
* |
||||
*------------------------------------------------------------------------- |
||||
*/ |
||||
#ifndef PROCARRAY_H |
||||
#define PROCARRAY_H |
||||
|
||||
extern int ProcArrayShmemSize(int maxBackends); |
||||
extern void CreateSharedProcArray(int maxBackends); |
||||
extern void ProcArrayAddMyself(void); |
||||
extern void ProcArrayRemoveMyself(void); |
||||
|
||||
extern bool TransactionIdIsInProgress(TransactionId xid); |
||||
extern TransactionId GetOldestXmin(bool allDbs); |
||||
|
||||
/* Use "struct PGPROC", not PGPROC, to avoid including proc.h here */ |
||||
extern struct PGPROC *BackendPidGetProc(int pid); |
||||
extern bool IsBackendPid(int pid); |
||||
extern bool DatabaseHasActiveBackends(Oid databaseId, bool ignoreMyself); |
||||
|
||||
extern int CountActiveBackends(void); |
||||
extern int CountEmptyBackendSlots(void); |
||||
|
||||
extern void XidCacheRemoveRunningXids(TransactionId xid, |
||||
int nxids, TransactionId *xids); |
||||
|
||||
#endif /* PROCARRAY_H */ |
||||
Loading…
Reference in new issue