mirror of
https://git.postgresql.org/git/postgresql.git
synced 2024-09-28 00:41:52 +02:00
Try to reduce confusion about what is a lock method identifier, a lock
method control structure, or a table of control structures.
. Use type LOCKMASK where an int is not a counter.
. Get rid of INVALID_TABLEID, use INVALID_LOCKMETHOD instead.
. Use INVALID_LOCKMETHOD instead of (LOCKMETHOD) NULL, because
LOCKMETHOD is not a pointer.
. Define and use macro LockMethodIsValid.
. Rename LOCKMETHOD to LOCKMETHODID.
. Remove global variable LongTermTableId in lmgr.c, because it is
never used.
. Make LockTableId static in lmgr.c, because it is used nowhere else.
Why not remove it and use DEFAULT_LOCKMETHOD?
. Rename the lock method control structure from LOCKMETHODTABLE to
LockMethodData. Introduce a pointer type named LockMethod.
. Remove elog(FATAL) after InitLockTable() call in
CreateSharedMemoryAndSemaphores(), because if something goes wrong,
there is elog(FATAL) in LockMethodTableInit(), and if this doesn't
help, an elog(ERROR) in InitLockTable() is promoted to FATAL.
. Make InitLockTable() void, because its only caller does not use its
return value any more.
. Rename variables in lock.c to avoid statements like
LockMethodTable[NumLockMethods] = lockMethodTable;
lockMethodTable = LockMethodTable[lockmethod];
. Change LOCKMETHODID type to uint16 to fit into struct LOCKTAG.
. Remove static variables BITS_OFF and BITS_ON from lock.c, because
I agree to this doubt:
* XXX is a fetch from a static array really faster than a shift?
. Define and use macros LOCKBIT_ON/OFF.
Manfred Koizar
This commit is contained in:
Bruce Momjian
parent
e2ac58c7bd
commit
e7ca867485
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/storage/ipc/ipci.c,v 1.58 2003/11/29 19:51:56 pgsql Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/storage/ipc/ipci.c,v 1.59 2003/12/01 21:59:25 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -111,8 +111,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate,
|
||||
* Set up lock manager
|
||||
*/
|
||||
InitLocks();
|
||||
if (InitLockTable(maxBackends) == INVALID_TABLEID)
|
||||
elog(FATAL, "could not create the lock table");
|
||||
InitLockTable(maxBackends);
|
||||
|
||||
/*
|
||||
* Set up process table
|
||||
|
||||
@ -12,7 +12,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/storage/lmgr/deadlock.c,v 1.26 2003/11/29 19:51:56 pgsql Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/storage/lmgr/deadlock.c,v 1.27 2003/12/01 21:59:25 momjian Exp $
|
||||
*
|
||||
* Interface:
|
||||
*
|
||||
@ -428,7 +428,7 @@ FindLockCycleRecurse(PGPROC *checkProc,
|
||||
LOCK *lock;
|
||||
PROCLOCK *proclock;
|
||||
SHM_QUEUE *lockHolders;
|
||||
LOCKMETHODTABLE *lockMethodTable;
|
||||
LockMethod lockMethodTable;
|
||||
PROC_QUEUE *waitQueue;
|
||||
int queue_size;
|
||||
int conflictMask;
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/storage/lmgr/lmgr.c,v 1.61 2003/11/29 19:51:56 pgsql Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/storage/lmgr/lmgr.c,v 1.62 2003/12/01 21:59:25 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -65,26 +65,24 @@ static LOCKMASK LockConflicts[] = {
|
||||
|
||||
};
|
||||
|
||||
LOCKMETHOD LockTableId = (LOCKMETHOD) NULL;
|
||||
LOCKMETHOD LongTermTableId = (LOCKMETHOD) NULL;
|
||||
static LOCKMETHODID LockTableId = INVALID_LOCKMETHOD;
|
||||
|
||||
/*
|
||||
* Create the lock table described by LockConflicts
|
||||
*/
|
||||
LOCKMETHOD
|
||||
void
|
||||
InitLockTable(int maxBackends)
|
||||
{
|
||||
int lockmethod;
|
||||
LOCKMETHODID LongTermTableId;
|
||||
|
||||
/* number of lock modes is lengthof()-1 because of dummy zero */
|
||||
lockmethod = LockMethodTableInit("LockTable",
|
||||
LockConflicts,
|
||||
lengthof(LockConflicts) - 1,
|
||||
maxBackends);
|
||||
LockTableId = lockmethod;
|
||||
|
||||
if (!(LockTableId))
|
||||
LockTableId = LockMethodTableInit("LockTable",
|
||||
LockConflicts,
|
||||
lengthof(LockConflicts) - 1,
|
||||
maxBackends);
|
||||
if (!LockMethodIsValid(LockTableId))
|
||||
elog(ERROR, "could not initialize lock table");
|
||||
Assert(LockTableId == DEFAULT_LOCKMETHOD);
|
||||
|
||||
#ifdef USER_LOCKS
|
||||
|
||||
@ -92,11 +90,10 @@ InitLockTable(int maxBackends)
|
||||
* Allocate another tableId for long-term locks
|
||||
*/
|
||||
LongTermTableId = LockMethodTableRename(LockTableId);
|
||||
if (!(LongTermTableId))
|
||||
if (!LockMethodIsValid(LongTermTableId))
|
||||
elog(ERROR, "could not rename long-term lock table");
|
||||
Assert(LongTermTableId == USER_LOCKMETHOD);
|
||||
#endif
|
||||
|
||||
return LockTableId;
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/storage/lmgr/lock.c,v 1.129 2003/11/29 19:51:56 pgsql Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/storage/lmgr/lock.c,v 1.130 2003/12/01 21:59:25 momjian Exp $
|
||||
*
|
||||
* NOTES
|
||||
* Outside modules can create a lock table and acquire/release
|
||||
@ -46,7 +46,7 @@ int max_locks_per_xact; /* set by guc.c */
|
||||
#define NLOCKENTS(maxBackends) (max_locks_per_xact * (maxBackends))
|
||||
|
||||
|
||||
static int WaitOnLock(LOCKMETHOD lockmethod, LOCKMODE lockmode,
|
||||
static int WaitOnLock(LOCKMETHODID lockmethodid, LOCKMODE lockmode,
|
||||
LOCK *lock, PROCLOCK *proclock);
|
||||
static void LockCountMyLocks(SHMEM_OFFSET lockOffset, PGPROC *proc,
|
||||
int *myHolding);
|
||||
@ -111,7 +111,7 @@ LOCK_PRINT(const char *where, const LOCK *lock, LOCKMODE type)
|
||||
"req(%d,%d,%d,%d,%d,%d,%d)=%d "
|
||||
"grant(%d,%d,%d,%d,%d,%d,%d)=%d wait(%d) type(%s)",
|
||||
where, MAKE_OFFSET(lock),
|
||||
lock->tag.lockmethod, lock->tag.relId, lock->tag.dbId,
|
||||
lock->tag.lockmethodid, lock->tag.relId, lock->tag.dbId,
|
||||
lock->tag.objId.blkno, lock->grantMask,
|
||||
lock->requested[1], lock->requested[2], lock->requested[3],
|
||||
lock->requested[4], lock->requested[5], lock->requested[6],
|
||||
@ -150,19 +150,9 @@ PROCLOCK_PRINT(const char *where, const PROCLOCK *proclockP)
|
||||
|
||||
|
||||
/*
|
||||
* These are to simplify/speed up some bit arithmetic.
|
||||
*
|
||||
* XXX is a fetch from a static array really faster than a shift?
|
||||
* Wouldn't bet on it...
|
||||
* map from lock method id to the lock table structure
|
||||
*/
|
||||
|
||||
static LOCKMASK BITS_OFF[MAX_LOCKMODES];
|
||||
static LOCKMASK BITS_ON[MAX_LOCKMODES];
|
||||
|
||||
/*
|
||||
* map from lockmethod to the lock table structure
|
||||
*/
|
||||
static LOCKMETHODTABLE *LockMethodTable[MAX_LOCK_METHODS];
|
||||
static LockMethod LockMethods[MAX_LOCK_METHODS];
|
||||
|
||||
static int NumLockMethods;
|
||||
|
||||
@ -173,28 +163,20 @@ static int NumLockMethods;
|
||||
void
|
||||
InitLocks(void)
|
||||
{
|
||||
int i;
|
||||
int bit;
|
||||
|
||||
bit = 1;
|
||||
for (i = 0; i < MAX_LOCKMODES; i++, bit <<= 1)
|
||||
{
|
||||
BITS_ON[i] = bit;
|
||||
BITS_OFF[i] = ~bit;
|
||||
}
|
||||
/* NOP */
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Fetch the lock method table associated with a given lock
|
||||
*/
|
||||
LOCKMETHODTABLE *
|
||||
LockMethod
|
||||
GetLocksMethodTable(LOCK *lock)
|
||||
{
|
||||
LOCKMETHOD lockmethod = LOCK_LOCKMETHOD(*lock);
|
||||
LOCKMETHODID lockmethodid = LOCK_LOCKMETHOD(*lock);
|
||||
|
||||
Assert(lockmethod > 0 && lockmethod < NumLockMethods);
|
||||
return LockMethodTable[lockmethod];
|
||||
Assert(0 < lockmethodid && lockmethodid < NumLockMethods);
|
||||
return LockMethods[lockmethodid];
|
||||
}
|
||||
|
||||
|
||||
@ -205,7 +187,7 @@ GetLocksMethodTable(LOCK *lock)
|
||||
* Notes: just copying. Should only be called once.
|
||||
*/
|
||||
static void
|
||||
LockMethodInit(LOCKMETHODTABLE *lockMethodTable,
|
||||
LockMethodInit(LockMethod lockMethodTable,
|
||||
LOCKMASK *conflictsP,
|
||||
int numModes)
|
||||
{
|
||||
@ -226,13 +208,13 @@ LockMethodInit(LOCKMETHODTABLE *lockMethodTable,
|
||||
* by the postmaster are inherited by each backend, so they must be in
|
||||
* TopMemoryContext.
|
||||
*/
|
||||
LOCKMETHOD
|
||||
LOCKMETHODID
|
||||
LockMethodTableInit(char *tabName,
|
||||
LOCKMASK *conflictsP,
|
||||
int numModes,
|
||||
int maxBackends)
|
||||
{
|
||||
LOCKMETHODTABLE *lockMethodTable;
|
||||
LockMethod newLockMethod;
|
||||
char *shmemName;
|
||||
HASHCTL info;
|
||||
int hash_flags;
|
||||
@ -254,10 +236,10 @@ LockMethodTableInit(char *tabName,
|
||||
|
||||
/* each lock table has a header in shared memory */
|
||||
sprintf(shmemName, "%s (lock method table)", tabName);
|
||||
lockMethodTable = (LOCKMETHODTABLE *)
|
||||
ShmemInitStruct(shmemName, sizeof(LOCKMETHODTABLE), &found);
|
||||
newLockMethod = (LockMethod)
|
||||
ShmemInitStruct(shmemName, sizeof(LockMethodData), &found);
|
||||
|
||||
if (!lockMethodTable)
|
||||
if (!newLockMethod)
|
||||
elog(FATAL, "could not initialize lock table \"%s\"", tabName);
|
||||
|
||||
/*
|
||||
@ -275,15 +257,15 @@ LockMethodTableInit(char *tabName,
|
||||
*/
|
||||
if (!found)
|
||||
{
|
||||
MemSet(lockMethodTable, 0, sizeof(LOCKMETHODTABLE));
|
||||
lockMethodTable->masterLock = LockMgrLock;
|
||||
lockMethodTable->lockmethod = NumLockMethods;
|
||||
MemSet(newLockMethod, 0, sizeof(LockMethodData));
|
||||
newLockMethod->masterLock = LockMgrLock;
|
||||
newLockMethod->lockmethodid = NumLockMethods;
|
||||
}
|
||||
|
||||
/*
|
||||
* other modules refer to the lock table by a lockmethod ID
|
||||
*/
|
||||
LockMethodTable[NumLockMethods] = lockMethodTable;
|
||||
LockMethods[NumLockMethods] = newLockMethod;
|
||||
NumLockMethods++;
|
||||
Assert(NumLockMethods <= MAX_LOCK_METHODS);
|
||||
|
||||
@ -297,15 +279,15 @@ LockMethodTableInit(char *tabName,
|
||||
hash_flags = (HASH_ELEM | HASH_FUNCTION);
|
||||
|
||||
sprintf(shmemName, "%s (lock hash)", tabName);
|
||||
lockMethodTable->lockHash = ShmemInitHash(shmemName,
|
||||
init_table_size,
|
||||
max_table_size,
|
||||
&info,
|
||||
hash_flags);
|
||||
newLockMethod->lockHash = ShmemInitHash(shmemName,
|
||||
init_table_size,
|
||||
max_table_size,
|
||||
&info,
|
||||
hash_flags);
|
||||
|
||||
if (!lockMethodTable->lockHash)
|
||||
if (!newLockMethod->lockHash)
|
||||
elog(FATAL, "could not initialize lock table \"%s\"", tabName);
|
||||
Assert(lockMethodTable->lockHash->hash == tag_hash);
|
||||
Assert(newLockMethod->lockHash->hash == tag_hash);
|
||||
|
||||
/*
|
||||
* allocate a hash table for PROCLOCK structs. This is used to store
|
||||
@ -317,23 +299,23 @@ LockMethodTableInit(char *tabName,
|
||||
hash_flags = (HASH_ELEM | HASH_FUNCTION);
|
||||
|
||||
sprintf(shmemName, "%s (proclock hash)", tabName);
|
||||
lockMethodTable->proclockHash = ShmemInitHash(shmemName,
|
||||
init_table_size,
|
||||
max_table_size,
|
||||
&info,
|
||||
hash_flags);
|
||||
newLockMethod->proclockHash = ShmemInitHash(shmemName,
|
||||
init_table_size,
|
||||
max_table_size,
|
||||
&info,
|
||||
hash_flags);
|
||||
|
||||
if (!lockMethodTable->proclockHash)
|
||||
if (!newLockMethod->proclockHash)
|
||||
elog(FATAL, "could not initialize lock table \"%s\"", tabName);
|
||||
|
||||
/* init data structures */
|
||||
LockMethodInit(lockMethodTable, conflictsP, numModes);
|
||||
LockMethodInit(newLockMethod, conflictsP, numModes);
|
||||
|
||||
LWLockRelease(LockMgrLock);
|
||||
|
||||
pfree(shmemName);
|
||||
|
||||
return lockMethodTable->lockmethod;
|
||||
return newLockMethod->lockmethodid;
|
||||
}
|
||||
|
||||
/*
|
||||
@ -349,22 +331,22 @@ LockMethodTableInit(char *tabName,
|
||||
* short term and long term locks, yet store them all in one hashtable.
|
||||
*/
|
||||
|
||||
LOCKMETHOD
|
||||
LockMethodTableRename(LOCKMETHOD lockmethod)
|
||||
LOCKMETHODID
|
||||
LockMethodTableRename(LOCKMETHODID lockmethodid)
|
||||
{
|
||||
LOCKMETHOD newLockMethod;
|
||||
LOCKMETHODID newLockMethodId;
|
||||
|
||||
if (NumLockMethods >= MAX_LOCK_METHODS)
|
||||
return INVALID_LOCKMETHOD;
|
||||
if (LockMethodTable[lockmethod] == INVALID_LOCKMETHOD)
|
||||
if (LockMethods[lockmethodid] == INVALID_LOCKMETHOD)
|
||||
return INVALID_LOCKMETHOD;
|
||||
|
||||
/* other modules refer to the lock table by a lockmethod ID */
|
||||
newLockMethod = NumLockMethods;
|
||||
newLockMethodId = NumLockMethods;
|
||||
NumLockMethods++;
|
||||
|
||||
LockMethodTable[newLockMethod] = LockMethodTable[lockmethod];
|
||||
return newLockMethod;
|
||||
LockMethods[newLockMethodId] = LockMethods[lockmethodid];
|
||||
return newLockMethodId;
|
||||
}
|
||||
|
||||
/*
|
||||
@ -412,7 +394,7 @@ LockMethodTableRename(LOCKMETHOD lockmethod)
|
||||
*
|
||||
* normal lock user lock
|
||||
*
|
||||
* lockmethod 1 2
|
||||
* lockmethodid 1 2
|
||||
* tag.dbId database oid database oid
|
||||
* tag.relId rel oid or 0 0
|
||||
* tag.objId block id lock id2
|
||||
@ -429,7 +411,7 @@ LockMethodTableRename(LOCKMETHOD lockmethod)
|
||||
*/
|
||||
|
||||
bool
|
||||
LockAcquire(LOCKMETHOD lockmethod, LOCKTAG *locktag,
|
||||
LockAcquire(LOCKMETHODID lockmethodid, LOCKTAG *locktag,
|
||||
TransactionId xid, LOCKMODE lockmode, bool dontWait)
|
||||
{
|
||||
PROCLOCK *proclock;
|
||||
@ -438,25 +420,25 @@ LockAcquire(LOCKMETHOD lockmethod, LOCKTAG *locktag,
|
||||
bool found;
|
||||
LOCK *lock;
|
||||
LWLockId masterLock;
|
||||
LOCKMETHODTABLE *lockMethodTable;
|
||||
LockMethod lockMethodTable;
|
||||
int status;
|
||||
int myHolding[MAX_LOCKMODES];
|
||||
int i;
|
||||
|
||||
#ifdef LOCK_DEBUG
|
||||
if (lockmethod == USER_LOCKMETHOD && Trace_userlocks)
|
||||
if (lockmethodid == USER_LOCKMETHOD && Trace_userlocks)
|
||||
elog(LOG, "LockAcquire: user lock [%u] %s",
|
||||
locktag->objId.blkno, lock_mode_names[lockmode]);
|
||||
#endif
|
||||
|
||||
/* ???????? This must be changed when short term locks will be used */
|
||||
locktag->lockmethod = lockmethod;
|
||||
locktag->lockmethodid = lockmethodid;
|
||||
|
||||
Assert(lockmethod < NumLockMethods);
|
||||
lockMethodTable = LockMethodTable[lockmethod];
|
||||
Assert(lockmethodid < NumLockMethods);
|
||||
lockMethodTable = LockMethods[lockmethodid];
|
||||
if (!lockMethodTable)
|
||||
{
|
||||
elog(WARNING, "bad lock table id: %d", lockmethod);
|
||||
elog(WARNING, "bad lock table id: %d", lockmethodid);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
@ -666,15 +648,12 @@ LockAcquire(LOCKMETHOD lockmethod, LOCKTAG *locktag,
|
||||
* Construct bitmask of locks this process holds on this object.
|
||||
*/
|
||||
{
|
||||
int heldLocks = 0;
|
||||
int tmpMask;
|
||||
LOCKMASK heldLocks = 0;
|
||||
|
||||
for (i = 1, tmpMask = 2;
|
||||
i <= lockMethodTable->numLockModes;
|
||||
i++, tmpMask <<= 1)
|
||||
for (i = 1; i <= lockMethodTable->numLockModes; i++)
|
||||
{
|
||||
if (myHolding[i] > 0)
|
||||
heldLocks |= tmpMask;
|
||||
heldLocks |= LOCKBIT_ON(i);
|
||||
}
|
||||
MyProc->heldLocks = heldLocks;
|
||||
}
|
||||
@ -682,7 +661,7 @@ LockAcquire(LOCKMETHOD lockmethod, LOCKTAG *locktag,
|
||||
/*
|
||||
* Sleep till someone wakes me up.
|
||||
*/
|
||||
status = WaitOnLock(lockmethod, lockmode, lock, proclock);
|
||||
status = WaitOnLock(lockmethodid, lockmode, lock, proclock);
|
||||
|
||||
/*
|
||||
* NOTE: do not do any material change of state between here and
|
||||
@ -729,7 +708,7 @@ LockAcquire(LOCKMETHOD lockmethod, LOCKTAG *locktag,
|
||||
* known. If NULL is passed then these values will be computed internally.
|
||||
*/
|
||||
int
|
||||
LockCheckConflicts(LOCKMETHODTABLE *lockMethodTable,
|
||||
LockCheckConflicts(LockMethod lockMethodTable,
|
||||
LOCKMODE lockmode,
|
||||
LOCK *lock,
|
||||
PROCLOCK *proclock,
|
||||
@ -737,9 +716,8 @@ LockCheckConflicts(LOCKMETHODTABLE *lockMethodTable,
|
||||
int *myHolding) /* myHolding[] array or NULL */
|
||||
{
|
||||
int numLockModes = lockMethodTable->numLockModes;
|
||||
int bitmask;
|
||||
int i,
|
||||
tmpMask;
|
||||
LOCKMASK bitmask;
|
||||
int i;
|
||||
int localHolding[MAX_LOCKMODES];
|
||||
|
||||
/*
|
||||
@ -772,11 +750,10 @@ LockCheckConflicts(LOCKMETHODTABLE *lockMethodTable,
|
||||
|
||||
/* Compute mask of lock types held by other processes */
|
||||
bitmask = 0;
|
||||
tmpMask = 2;
|
||||
for (i = 1; i <= numLockModes; i++, tmpMask <<= 1)
|
||||
for (i = 1; i <= numLockModes; i++)
|
||||
{
|
||||
if (lock->granted[i] != myHolding[i])
|
||||
bitmask |= tmpMask;
|
||||
bitmask |= LOCKBIT_ON(i);
|
||||
}
|
||||
|
||||
/*
|
||||
@ -842,9 +819,9 @@ GrantLock(LOCK *lock, PROCLOCK *proclock, LOCKMODE lockmode)
|
||||
{
|
||||
lock->nGranted++;
|
||||
lock->granted[lockmode]++;
|
||||
lock->grantMask |= BITS_ON[lockmode];
|
||||
lock->grantMask |= LOCKBIT_ON(lockmode);
|
||||
if (lock->granted[lockmode] == lock->requested[lockmode])
|
||||
lock->waitMask &= BITS_OFF[lockmode];
|
||||
lock->waitMask &= LOCKBIT_OFF(lockmode);
|
||||
LOCK_PRINT("GrantLock", lock, lockmode);
|
||||
Assert((lock->nGranted > 0) && (lock->granted[lockmode] > 0));
|
||||
Assert(lock->nGranted <= lock->nRequested);
|
||||
@ -862,14 +839,14 @@ GrantLock(LOCK *lock, PROCLOCK *proclock, LOCKMODE lockmode)
|
||||
* The locktable's masterLock must be held at entry.
|
||||
*/
|
||||
static int
|
||||
WaitOnLock(LOCKMETHOD lockmethod, LOCKMODE lockmode,
|
||||
WaitOnLock(LOCKMETHODID lockmethodid, LOCKMODE lockmode,
|
||||
LOCK *lock, PROCLOCK *proclock)
|
||||
{
|
||||
LOCKMETHODTABLE *lockMethodTable = LockMethodTable[lockmethod];
|
||||
LockMethod lockMethodTable = LockMethods[lockmethodid];
|
||||
char *new_status,
|
||||
*old_status;
|
||||
|
||||
Assert(lockmethod < NumLockMethods);
|
||||
Assert(lockmethodid < NumLockMethods);
|
||||
|
||||
LOCK_PRINT("WaitOnLock: sleeping on lock", lock, lockmode);
|
||||
|
||||
@ -957,7 +934,7 @@ RemoveFromWaitQueue(PGPROC *proc)
|
||||
waitLock->requested[lockmode]--;
|
||||
/* don't forget to clear waitMask bit if appropriate */
|
||||
if (waitLock->granted[lockmode] == waitLock->requested[lockmode])
|
||||
waitLock->waitMask &= BITS_OFF[lockmode];
|
||||
waitLock->waitMask &= LOCKBIT_OFF(lockmode);
|
||||
|
||||
/* Clean up the proc's own state */
|
||||
proc->waitLock = NULL;
|
||||
@ -968,7 +945,7 @@ RemoveFromWaitQueue(PGPROC *proc)
|
||||
}
|
||||
|
||||
/*
|
||||
* LockRelease -- look up 'locktag' in lock table 'lockmethod' and
|
||||
* LockRelease -- look up 'locktag' in lock table 'lockmethodid' and
|
||||
* release one 'lockmode' lock on it.
|
||||
*
|
||||
* Side Effects: find any waiting processes that are now wakable,
|
||||
@ -978,27 +955,27 @@ RemoveFromWaitQueue(PGPROC *proc)
|
||||
* come along and request the lock.)
|
||||
*/
|
||||
bool
|
||||
LockRelease(LOCKMETHOD lockmethod, LOCKTAG *locktag,
|
||||
LockRelease(LOCKMETHODID lockmethodid, LOCKTAG *locktag,
|
||||
TransactionId xid, LOCKMODE lockmode)
|
||||
{
|
||||
LOCK *lock;
|
||||
LWLockId masterLock;
|
||||
LOCKMETHODTABLE *lockMethodTable;
|
||||
LockMethod lockMethodTable;
|
||||
PROCLOCK *proclock;
|
||||
PROCLOCKTAG proclocktag;
|
||||
HTAB *proclockTable;
|
||||
bool wakeupNeeded = false;
|
||||
|
||||
#ifdef LOCK_DEBUG
|
||||
if (lockmethod == USER_LOCKMETHOD && Trace_userlocks)
|
||||
if (lockmethodid == USER_LOCKMETHOD && Trace_userlocks)
|
||||
elog(LOG, "LockRelease: user lock tag [%u] %d", locktag->objId.blkno, lockmode);
|
||||
#endif
|
||||
|
||||
/* ???????? This must be changed when short term locks will be used */
|
||||
locktag->lockmethod = lockmethod;
|
||||
locktag->lockmethodid = lockmethodid;
|
||||
|
||||
Assert(lockmethod < NumLockMethods);
|
||||
lockMethodTable = LockMethodTable[lockmethod];
|
||||
Assert(lockmethodid < NumLockMethods);
|
||||
lockMethodTable = LockMethods[lockmethodid];
|
||||
if (!lockMethodTable)
|
||||
{
|
||||
elog(WARNING, "lockMethodTable is null in LockRelease");
|
||||
@ -1045,7 +1022,7 @@ LockRelease(LOCKMETHOD lockmethod, LOCKTAG *locktag,
|
||||
{
|
||||
LWLockRelease(masterLock);
|
||||
#ifdef USER_LOCKS
|
||||
if (lockmethod == USER_LOCKMETHOD)
|
||||
if (lockmethodid == USER_LOCKMETHOD)
|
||||
elog(WARNING, "no lock with this tag");
|
||||
else
|
||||
#endif
|
||||
@ -1083,7 +1060,7 @@ LockRelease(LOCKMETHOD lockmethod, LOCKTAG *locktag,
|
||||
if (lock->granted[lockmode] == 0)
|
||||
{
|
||||
/* change the conflict mask. No more of this lock type. */
|
||||
lock->grantMask &= BITS_OFF[lockmode];
|
||||
lock->grantMask &= LOCKBIT_OFF(lockmode);
|
||||
}
|
||||
|
||||
LOCK_PRINT("LockRelease: updated", lock, lockmode);
|
||||
@ -1173,29 +1150,29 @@ LockRelease(LOCKMETHOD lockmethod, LOCKTAG *locktag,
|
||||
* specified XID are released.
|
||||
*/
|
||||
bool
|
||||
LockReleaseAll(LOCKMETHOD lockmethod, PGPROC *proc,
|
||||
LockReleaseAll(LOCKMETHODID lockmethodid, PGPROC *proc,
|
||||
bool allxids, TransactionId xid)
|
||||
{
|
||||
SHM_QUEUE *procHolders = &(proc->procHolders);
|
||||
PROCLOCK *proclock;
|
||||
PROCLOCK *nextHolder;
|
||||
LWLockId masterLock;
|
||||
LOCKMETHODTABLE *lockMethodTable;
|
||||
LockMethod lockMethodTable;
|
||||
int i,
|
||||
numLockModes;
|
||||
LOCK *lock;
|
||||
|
||||
#ifdef LOCK_DEBUG
|
||||
if (lockmethod == USER_LOCKMETHOD ? Trace_userlocks : Trace_locks)
|
||||
if (lockmethodid == USER_LOCKMETHOD ? Trace_userlocks : Trace_locks)
|
||||
elog(LOG, "LockReleaseAll: lockmethod=%d, pid=%d",
|
||||
lockmethod, proc->pid);
|
||||
lockmethodid, proc->pid);
|
||||
#endif
|
||||
|
||||
Assert(lockmethod < NumLockMethods);
|
||||
lockMethodTable = LockMethodTable[lockmethod];
|
||||
Assert(lockmethodid < NumLockMethods);
|
||||
lockMethodTable = LockMethods[lockmethodid];
|
||||
if (!lockMethodTable)
|
||||
{
|
||||
elog(WARNING, "bad lock method: %d", lockmethod);
|
||||
elog(WARNING, "bad lock method: %d", lockmethodid);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
@ -1220,7 +1197,7 @@ LockReleaseAll(LOCKMETHOD lockmethod, PGPROC *proc,
|
||||
lock = (LOCK *) MAKE_PTR(proclock->tag.lock);
|
||||
|
||||
/* Ignore items that are not of the lockmethod to be removed */
|
||||
if (LOCK_LOCKMETHOD(*lock) != lockmethod)
|
||||
if (LOCK_LOCKMETHOD(*lock) != lockmethodid)
|
||||
goto next_item;
|
||||
|
||||
/* If not allxids, ignore items that are of the wrong xid */
|
||||
@ -1249,7 +1226,7 @@ LockReleaseAll(LOCKMETHOD lockmethod, PGPROC *proc,
|
||||
lock->granted[i] -= proclock->holding[i];
|
||||
Assert(lock->requested[i] >= 0 && lock->granted[i] >= 0);
|
||||
if (lock->granted[i] == 0)
|
||||
lock->grantMask &= BITS_OFF[i];
|
||||
lock->grantMask &= LOCKBIT_OFF(i);
|
||||
|
||||
/*
|
||||
* Read comments in LockRelease
|
||||
@ -1331,7 +1308,7 @@ next_item:
|
||||
LWLockRelease(masterLock);
|
||||
|
||||
#ifdef LOCK_DEBUG
|
||||
if (lockmethod == USER_LOCKMETHOD ? Trace_userlocks : Trace_locks)
|
||||
if (lockmethodid == USER_LOCKMETHOD ? Trace_userlocks : Trace_locks)
|
||||
elog(LOG, "LockReleaseAll done");
|
||||
#endif
|
||||
|
||||
@ -1346,7 +1323,7 @@ LockShmemSize(int maxBackends)
|
||||
|
||||
size += MAXALIGN(sizeof(PROC_HDR)); /* ProcGlobal */
|
||||
size += maxBackends * MAXALIGN(sizeof(PGPROC)); /* each MyProc */
|
||||
size += MAX_LOCK_METHODS * MAXALIGN(sizeof(LOCKMETHODTABLE)); /* each lockMethodTable */
|
||||
size += MAX_LOCK_METHODS * MAXALIGN(sizeof(LockMethodData)); /* each lock method */
|
||||
|
||||
/* lockHash table */
|
||||
size += hash_estimate_size(max_table_size, sizeof(LOCK));
|
||||
@ -1390,7 +1367,7 @@ GetLockStatusData(void)
|
||||
|
||||
LWLockAcquire(LockMgrLock, LW_EXCLUSIVE);
|
||||
|
||||
proclockTable = LockMethodTable[DEFAULT_LOCKMETHOD]->proclockHash;
|
||||
proclockTable = LockMethods[DEFAULT_LOCKMETHOD]->proclockHash;
|
||||
|
||||
data->nelements = i = proclockTable->hctl->nentries;
|
||||
|
||||
@ -1446,8 +1423,8 @@ DumpLocks(void)
|
||||
SHM_QUEUE *procHolders;
|
||||
PROCLOCK *proclock;
|
||||
LOCK *lock;
|
||||
int lockmethod = DEFAULT_LOCKMETHOD;
|
||||
LOCKMETHODTABLE *lockMethodTable;
|
||||
int lockmethodid = DEFAULT_LOCKMETHOD;
|
||||
LockMethod lockMethodTable;
|
||||
|
||||
proc = MyProc;
|
||||
if (proc == NULL)
|
||||
@ -1455,8 +1432,8 @@ DumpLocks(void)
|
||||
|
||||
procHolders = &proc->procHolders;
|
||||
|
||||
Assert(lockmethod < NumLockMethods);
|
||||
lockMethodTable = LockMethodTable[lockmethod];
|
||||
Assert(lockmethodid < NumLockMethods);
|
||||
lockMethodTable = LockMethods[lockmethodid];
|
||||
if (!lockMethodTable)
|
||||
return;
|
||||
|
||||
@ -1489,8 +1466,8 @@ DumpAllLocks(void)
|
||||
PGPROC *proc;
|
||||
PROCLOCK *proclock;
|
||||
LOCK *lock;
|
||||
int lockmethod = DEFAULT_LOCKMETHOD;
|
||||
LOCKMETHODTABLE *lockMethodTable;
|
||||
int lockmethodid = DEFAULT_LOCKMETHOD;
|
||||
LockMethod lockMethodTable;
|
||||
HTAB *proclockTable;
|
||||
HASH_SEQ_STATUS status;
|
||||
|
||||
@ -1498,8 +1475,8 @@ DumpAllLocks(void)
|
||||
if (proc == NULL)
|
||||
return;
|
||||
|
||||
Assert(lockmethod < NumLockMethods);
|
||||
lockMethodTable = LockMethodTable[lockmethod];
|
||||
Assert(lockmethodid < NumLockMethods);
|
||||
lockMethodTable = LockMethods[lockmethodid];
|
||||
if (!lockMethodTable)
|
||||
return;
|
||||
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/storage/lmgr/proc.c,v 1.138 2003/11/29 19:51:57 pgsql Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/storage/lmgr/proc.c,v 1.139 2003/12/01 21:59:25 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -543,14 +543,14 @@ ProcQueueInit(PROC_QUEUE *queue)
|
||||
* semaphore is normally zero, so when we try to acquire it, we sleep.
|
||||
*/
|
||||
int
|
||||
ProcSleep(LOCKMETHODTABLE *lockMethodTable,
|
||||
ProcSleep(LockMethod lockMethodTable,
|
||||
LOCKMODE lockmode,
|
||||
LOCK *lock,
|
||||
PROCLOCK *proclock)
|
||||
{
|
||||
LWLockId masterLock = lockMethodTable->masterLock;
|
||||
PROC_QUEUE *waitQueue = &(lock->waitProcs);
|
||||
int myHeldLocks = MyProc->heldLocks;
|
||||
LOCKMASK myHeldLocks = MyProc->heldLocks;
|
||||
bool early_deadlock = false;
|
||||
PGPROC *proc;
|
||||
int i;
|
||||
@ -575,7 +575,7 @@ ProcSleep(LOCKMETHODTABLE *lockMethodTable,
|
||||
*/
|
||||
if (myHeldLocks != 0)
|
||||
{
|
||||
int aheadRequests = 0;
|
||||
LOCKMASK aheadRequests = 0;
|
||||
|
||||
proc = (PGPROC *) MAKE_PTR(waitQueue->links.next);
|
||||
for (i = 0; i < waitQueue->size; i++)
|
||||
@ -615,7 +615,7 @@ ProcSleep(LOCKMETHODTABLE *lockMethodTable,
|
||||
break;
|
||||
}
|
||||
/* Nope, so advance to next waiter */
|
||||
aheadRequests |= (1 << proc->waitLockMode);
|
||||
aheadRequests |= LOCKBIT_ON(proc->waitLockMode);
|
||||
proc = (PGPROC *) MAKE_PTR(proc->links.next);
|
||||
}
|
||||
|
||||
@ -637,7 +637,7 @@ ProcSleep(LOCKMETHODTABLE *lockMethodTable,
|
||||
SHMQueueInsertBefore(&(proc->links), &(MyProc->links));
|
||||
waitQueue->size++;
|
||||
|
||||
lock->waitMask |= (1 << lockmode);
|
||||
lock->waitMask |= LOCKBIT_ON(lockmode);
|
||||
|
||||
/* Set up wait information in PGPROC object, too */
|
||||
MyProc->waitLock = lock;
|
||||
@ -769,12 +769,12 @@ ProcWakeup(PGPROC *proc, int errType)
|
||||
* for lock, waken any that are no longer blocked.
|
||||
*/
|
||||
void
|
||||
ProcLockWakeup(LOCKMETHODTABLE *lockMethodTable, LOCK *lock)
|
||||
ProcLockWakeup(LockMethod lockMethodTable, LOCK *lock)
|
||||
{
|
||||
PROC_QUEUE *waitQueue = &(lock->waitProcs);
|
||||
int queue_size = waitQueue->size;
|
||||
PGPROC *proc;
|
||||
int aheadRequests = 0;
|
||||
LOCKMASK aheadRequests = 0;
|
||||
|
||||
Assert(queue_size >= 0);
|
||||
|
||||
@ -815,7 +815,7 @@ ProcLockWakeup(LOCKMETHODTABLE *lockMethodTable, LOCK *lock)
|
||||
* Cannot wake this guy. Remember his request for later
|
||||
* checks.
|
||||
*/
|
||||
aheadRequests |= (1 << lockmode);
|
||||
aheadRequests |= LOCKBIT_ON(lockmode);
|
||||
proc = (PGPROC *) MAKE_PTR(proc->links.next);
|
||||
}
|
||||
}
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $PostgreSQL: pgsql/src/include/storage/lmgr.h,v 1.41 2003/11/29 22:41:13 pgsql Exp $
|
||||
* $PostgreSQL: pgsql/src/include/storage/lmgr.h,v 1.42 2003/12/01 21:59:25 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -40,10 +40,7 @@
|
||||
* so increase that if you want to add more modes.
|
||||
*/
|
||||
|
||||
extern LOCKMETHOD LockTableId;
|
||||
|
||||
|
||||
extern LOCKMETHOD InitLockTable(int maxBackends);
|
||||
extern void InitLockTable(int maxBackends);
|
||||
extern void RelationInitLockInfo(Relation relation);
|
||||
|
||||
/* Lock a relation */
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $PostgreSQL: pgsql/src/include/storage/lock.h,v 1.74 2003/11/29 22:41:13 pgsql Exp $
|
||||
* $PostgreSQL: pgsql/src/include/storage/lock.h,v 1.75 2003/12/01 21:59:25 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -42,22 +42,23 @@ extern bool Debug_deadlocks;
|
||||
|
||||
|
||||
typedef int LOCKMASK;
|
||||
|
||||
typedef int LOCKMODE;
|
||||
typedef int LOCKMETHOD;
|
||||
|
||||
/* MAX_LOCKMODES cannot be larger than the # of bits in LOCKMASK */
|
||||
#define MAX_LOCKMODES 10
|
||||
|
||||
#define LOCKBIT_ON(lockmode) (1 << (lockmode))
|
||||
#define LOCKBIT_OFF(lockmode) (~(1 << (lockmode)))
|
||||
|
||||
typedef uint16 LOCKMETHODID;
|
||||
/* MAX_LOCK_METHODS is the number of distinct lock control tables allowed */
|
||||
#define MAX_LOCK_METHODS 3
|
||||
|
||||
#define INVALID_TABLEID 0
|
||||
|
||||
#define INVALID_LOCKMETHOD INVALID_TABLEID
|
||||
#define INVALID_LOCKMETHOD 0
|
||||
#define DEFAULT_LOCKMETHOD 1
|
||||
#define USER_LOCKMETHOD 2
|
||||
|
||||
#define LockMethodIsValid(lockmethodid) ((lockmethodid) != INVALID_LOCKMETHOD)
|
||||
|
||||
/*
|
||||
* There is normally only one lock method, the default one.
|
||||
* If user locks are enabled, an additional lock method is present.
|
||||
@ -83,15 +84,16 @@ typedef int LOCKMETHOD;
|
||||
* masterLock -- synchronizes access to the table
|
||||
*
|
||||
*/
|
||||
typedef struct LOCKMETHODTABLE
|
||||
typedef struct LockMethodData
|
||||
{
|
||||
HTAB *lockHash;
|
||||
HTAB *proclockHash;
|
||||
LOCKMETHOD lockmethod;
|
||||
int numLockModes;
|
||||
int conflictTab[MAX_LOCKMODES];
|
||||
LWLockId masterLock;
|
||||
} LOCKMETHODTABLE;
|
||||
HTAB *lockHash;
|
||||
HTAB *proclockHash;
|
||||
LOCKMETHODID lockmethodid;
|
||||
int numLockModes;
|
||||
LOCKMASK conflictTab[MAX_LOCKMODES];
|
||||
LWLockId masterLock;
|
||||
} LockMethodData;
|
||||
typedef LockMethodData *LockMethod;
|
||||
|
||||
|
||||
/*
|
||||
@ -115,7 +117,7 @@ typedef struct LOCKTAG
|
||||
*/
|
||||
OffsetNumber offnum;
|
||||
|
||||
uint16 lockmethod; /* needed by userlocks */
|
||||
LOCKMETHODID lockmethodid; /* needed by userlocks */
|
||||
} LOCKTAG;
|
||||
|
||||
|
||||
@ -139,8 +141,8 @@ typedef struct LOCK
|
||||
LOCKTAG tag; /* unique identifier of lockable object */
|
||||
|
||||
/* data */
|
||||
int grantMask; /* bitmask for lock types already granted */
|
||||
int waitMask; /* bitmask for lock types awaited */
|
||||
LOCKMASK grantMask; /* bitmask for lock types already granted */
|
||||
LOCKMASK waitMask; /* bitmask for lock types awaited */
|
||||
SHM_QUEUE lockHolders; /* list of PROCLOCK objects assoc. with
|
||||
* lock */
|
||||
PROC_QUEUE waitProcs; /* list of PGPROC objects waiting on lock */
|
||||
@ -151,7 +153,7 @@ typedef struct LOCK
|
||||
int nGranted; /* total of granted[] array */
|
||||
} LOCK;
|
||||
|
||||
#define LOCK_LOCKMETHOD(lock) ((lock).tag.lockmethod)
|
||||
#define LOCK_LOCKMETHOD(lock) ((lock).tag.lockmethodid)
|
||||
|
||||
|
||||
/*
|
||||
@ -204,7 +206,7 @@ typedef struct PROCLOCK
|
||||
} PROCLOCK;
|
||||
|
||||
#define PROCLOCK_LOCKMETHOD(proclock) \
|
||||
(((LOCK *) MAKE_PTR((proclock).tag.lock))->tag.lockmethod)
|
||||
(((LOCK *) MAKE_PTR((proclock).tag.lock))->tag.lockmethodid)
|
||||
|
||||
/*
|
||||
* This struct holds information passed from lmgr internals to the lock
|
||||
@ -227,17 +229,17 @@ typedef struct
|
||||
* function prototypes
|
||||
*/
|
||||
extern void InitLocks(void);
|
||||
extern LOCKMETHODTABLE *GetLocksMethodTable(LOCK *lock);
|
||||
extern LOCKMETHOD LockMethodTableInit(char *tabName, LOCKMASK *conflictsP,
|
||||
extern LockMethod GetLocksMethodTable(LOCK *lock);
|
||||
extern LOCKMETHODID LockMethodTableInit(char *tabName, LOCKMASK *conflictsP,
|
||||
int numModes, int maxBackends);
|
||||
extern LOCKMETHOD LockMethodTableRename(LOCKMETHOD lockmethod);
|
||||
extern bool LockAcquire(LOCKMETHOD lockmethod, LOCKTAG *locktag,
|
||||
extern LOCKMETHODID LockMethodTableRename(LOCKMETHODID lockmethodid);
|
||||
extern bool LockAcquire(LOCKMETHODID lockmethodid, LOCKTAG *locktag,
|
||||
TransactionId xid, LOCKMODE lockmode, bool dontWait);
|
||||
extern bool LockRelease(LOCKMETHOD lockmethod, LOCKTAG *locktag,
|
||||
extern bool LockRelease(LOCKMETHODID lockmethodid, LOCKTAG *locktag,
|
||||
TransactionId xid, LOCKMODE lockmode);
|
||||
extern bool LockReleaseAll(LOCKMETHOD lockmethod, PGPROC *proc,
|
||||
extern bool LockReleaseAll(LOCKMETHODID lockmethodid, PGPROC *proc,
|
||||
bool allxids, TransactionId xid);
|
||||
extern int LockCheckConflicts(LOCKMETHODTABLE *lockMethodTable,
|
||||
extern int LockCheckConflicts(LockMethod lockMethodTable,
|
||||
LOCKMODE lockmode,
|
||||
LOCK *lock, PROCLOCK *proclock, PGPROC *proc,
|
||||
int *myHolding);
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $PostgreSQL: pgsql/src/include/storage/proc.h,v 1.66 2003/11/29 22:41:13 pgsql Exp $
|
||||
* $PostgreSQL: pgsql/src/include/storage/proc.h,v 1.67 2003/12/01 21:59:25 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -106,10 +106,10 @@ extern void InitDummyProcess(int proctype);
|
||||
extern void ProcReleaseLocks(bool isCommit);
|
||||
|
||||
extern void ProcQueueInit(PROC_QUEUE *queue);
|
||||
extern int ProcSleep(LOCKMETHODTABLE *lockMethodTable, LOCKMODE lockmode,
|
||||
extern int ProcSleep(LockMethod lockMethodTable, LOCKMODE lockmode,
|
||||
LOCK *lock, PROCLOCK *proclock);
|
||||
extern PGPROC *ProcWakeup(PGPROC *proc, int errType);
|
||||
extern void ProcLockWakeup(LOCKMETHODTABLE *lockMethodTable, LOCK *lock);
|
||||
extern void ProcLockWakeup(LockMethod lockMethodTable, LOCK *lock);
|
||||
extern bool LockWaitCancel(void);
|
||||
|
||||
extern void ProcWaitForSignal(void);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user