Remove multi.c and single.c, which have been dead code for
over two years.
This commit is contained in:
Tom Lane
parent
39b547f430
commit
e6e9e18e9e
@ -1,453 +0,0 @@
|
||||
/*-------------------------------------------------------------------------
|
||||
*
|
||||
* multi.c
|
||||
* multi level lock table manager
|
||||
*
|
||||
* Standard multi-level lock manager as per the Gray paper
|
||||
* (at least, that is what it is supposed to be). We implement
|
||||
* three levels -- RELN, PAGE, TUPLE. Tuple is actually TID
|
||||
* a physical record pointer. It isn't an object id.
|
||||
*
|
||||
* Portions Copyright (c) 1996-2000, PostgreSQL, Inc
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/Attic/multi.c,v 1.34 2000/01/26 05:57:02 momjian Exp $
|
||||
*
|
||||
* NOTES:
|
||||
* (1) The lock.c module assumes that the caller here is doing
|
||||
* two phase locking.
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
#include "postgres.h"
|
||||
|
||||
#include "miscadmin.h"
|
||||
#include "storage/lmgr.h"
|
||||
#include "storage/multilev.h"
|
||||
#include "utils/rel.h"
|
||||
|
||||
static bool MultiAcquire(LOCKMETHOD lockmethod, LOCKTAG *tag,
|
||||
LOCKMODE lockmode, PG_LOCK_LEVEL level);
|
||||
static bool MultiRelease(LOCKMETHOD lockmethod, LOCKTAG *tag,
|
||||
LOCKMODE lockmode, PG_LOCK_LEVEL level);
|
||||
|
||||
/*
|
||||
* INTENT indicates to higher level that a lower level lock has been
|
||||
* set. For example, a write lock on a tuple conflicts with a write
|
||||
* lock on a relation. This conflict is detected as a WRITE_INTENT/
|
||||
* WRITE conflict between the tuple's intent lock and the relation's
|
||||
* write lock.
|
||||
*/
|
||||
static LOCKMASK MultiConflicts[] = {
|
||||
(int) NULL,
|
||||
/* All reads and writes at any level conflict with a write lock */
|
||||
(1 << WRITE_LOCK) | (1 << WRITE_INTENT) | (1 << READ_LOCK) | (1 << READ_INTENT),
|
||||
/* read locks conflict with write locks at curr and lower levels */
|
||||
(1 << WRITE_LOCK) | (1 << WRITE_INTENT),
|
||||
/* write intent locks */
|
||||
(1 << READ_LOCK) | (1 << WRITE_LOCK),
|
||||
/* read intent locks */
|
||||
(1 << WRITE_LOCK),
|
||||
|
||||
/*
|
||||
* extend locks for archive storage manager conflict only w/extend
|
||||
* locks
|
||||
*/
|
||||
(1 << EXTEND_LOCK)
|
||||
};
|
||||
|
||||
/*
|
||||
* write locks have higher priority than read locks and extend locks. May
|
||||
* want to treat INTENT locks differently.
|
||||
*/
|
||||
static int MultiPrios[] = {
|
||||
(int) NULL,
|
||||
2,
|
||||
1,
|
||||
2,
|
||||
1,
|
||||
1
|
||||
};
|
||||
|
||||
/*
|
||||
* Lock table identifier for this lock table. The multi-level
|
||||
* lock table is ONE lock table, not three.
|
||||
*/
|
||||
LOCKMETHOD MultiTableId = (LOCKMETHOD) NULL;
|
||||
LOCKMETHOD LongTermTableId = (LOCKMETHOD) NULL;
|
||||
|
||||
#ifdef NOT_USED
|
||||
LOCKMETHOD ShortTermTableId = (LOCKMETHOD) NULL;
|
||||
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Create the lock table described by MultiConflicts and Multiprio.
|
||||
*/
|
||||
LOCKMETHOD
|
||||
InitMultiLevelLocks()
|
||||
{
|
||||
int lockmethod;
|
||||
|
||||
lockmethod = LockMethodTableInit("MultiLevelLockTable",
|
||||
MultiConflicts, MultiPrios, MAX_LOCKMODES - 1);
|
||||
MultiTableId = lockmethod;
|
||||
if (!(MultiTableId))
|
||||
elog(ERROR, "InitMultiLocks: couldnt initialize lock table");
|
||||
/* -----------------------
|
||||
* No short term lock table for now. -Jeff 15 July 1991
|
||||
*
|
||||
* ShortTermTableId = LockMethodTableRename(lockmethod);
|
||||
* if (! (ShortTermTableId)) {
|
||||
* elog(ERROR,"InitMultiLocks: couldnt rename lock table");
|
||||
* }
|
||||
* -----------------------
|
||||
*/
|
||||
|
||||
#ifdef USER_LOCKS
|
||||
|
||||
/*
|
||||
* Allocate another tableId for long-term locks
|
||||
*/
|
||||
LongTermTableId = LockMethodTableRename(MultiTableId);
|
||||
if (!(LongTermTableId))
|
||||
{
|
||||
elog(ERROR,
|
||||
"InitMultiLevelLocks: couldn't rename long-term lock table");
|
||||
}
|
||||
#endif
|
||||
|
||||
return MultiTableId;
|
||||
}
|
||||
|
||||
/*
|
||||
* MultiLockReln -- lock a relation
|
||||
*
|
||||
* Returns: TRUE if the lock can be set, FALSE otherwise.
|
||||
*/
|
||||
bool
|
||||
MultiLockReln(LockInfo lockinfo, LOCKMODE lockmode)
|
||||
{
|
||||
LOCKTAG tag;
|
||||
|
||||
/*
|
||||
* LOCKTAG has two bytes of padding, unfortunately. The hash function
|
||||
* will return miss if the padding bytes aren't zero'd.
|
||||
*/
|
||||
MemSet(&tag, 0, sizeof(tag));
|
||||
tag.relId = lockinfo->lockRelId.relId;
|
||||
tag.dbId = lockinfo->lockRelId.dbId;
|
||||
return MultiAcquire(MultiTableId, &tag, lockmode, RELN_LEVEL);
|
||||
}
|
||||
|
||||
#ifdef NOT_USED
|
||||
/*
|
||||
* MultiLockTuple -- Lock the TID associated with a tuple
|
||||
*
|
||||
* Returns: TRUE if lock is set, FALSE otherwise.
|
||||
*
|
||||
* Side Effects: causes intention level locks to be set
|
||||
* at the page and relation level.
|
||||
*/
|
||||
bool
|
||||
MultiLockTuple(LockInfo lockinfo, ItemPointer tidPtr, LOCKMODE lockmode)
|
||||
{
|
||||
LOCKTAG tag;
|
||||
|
||||
/*
|
||||
* LOCKTAG has two bytes of padding, unfortunately. The hash function
|
||||
* will return miss if the padding bytes aren't zero'd.
|
||||
*/
|
||||
MemSet(&tag, 0, sizeof(tag));
|
||||
|
||||
tag.relId = lockinfo->lockRelId.relId;
|
||||
tag.dbId = lockinfo->lockRelId.dbId;
|
||||
|
||||
/* not locking any valid Tuple, just the page */
|
||||
tag.tupleId = *tidPtr;
|
||||
return MultiAcquire(MultiTableId, &tag, lockmode, TUPLE_LEVEL);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
/*
|
||||
* same as above at page level
|
||||
*/
|
||||
bool
|
||||
MultiLockPage(LockInfo lockinfo, ItemPointer tidPtr, LOCKMODE lockmode)
|
||||
{
|
||||
LOCKTAG tag;
|
||||
|
||||
/*
|
||||
* LOCKTAG has two bytes of padding, unfortunately. The hash function
|
||||
* will return miss if the padding bytes aren't zero'd.
|
||||
*/
|
||||
MemSet(&tag, 0, sizeof(tag));
|
||||
|
||||
|
||||
/* ----------------------------
|
||||
* Now we want to set the page offset to be invalid
|
||||
* and lock the block. There is some confusion here as to what
|
||||
* a page is. In Postgres a page is an 8k block, however this
|
||||
* block may be partitioned into many subpages which are sometimes
|
||||
* also called pages. The term is overloaded, so don't be fooled
|
||||
* when we say lock the page we mean the 8k block. -Jeff 16 July 1991
|
||||
* ----------------------------
|
||||
*/
|
||||
tag.relId = lockinfo->lockRelId.relId;
|
||||
tag.dbId = lockinfo->lockRelId.dbId;
|
||||
BlockIdCopy(&(tag.tupleId.ip_blkid), &(tidPtr->ip_blkid));
|
||||
return MultiAcquire(MultiTableId, &tag, lockmode, PAGE_LEVEL);
|
||||
}
|
||||
|
||||
/*
|
||||
* MultiAcquire -- acquire multi level lock at requested level
|
||||
*
|
||||
* Returns: TRUE if lock is set, FALSE if not
|
||||
* Side Effects:
|
||||
*/
|
||||
static bool
|
||||
MultiAcquire(LOCKMETHOD lockmethod,
|
||||
LOCKTAG *tag,
|
||||
LOCKMODE lockmode,
|
||||
PG_LOCK_LEVEL level)
|
||||
{
|
||||
LOCKMODE locks[N_LEVELS];
|
||||
int i,
|
||||
status;
|
||||
LOCKTAG xxTag,
|
||||
*tmpTag = &xxTag;
|
||||
int retStatus = TRUE;
|
||||
|
||||
/*
|
||||
* Three levels implemented. If we set a low level (e.g. Tuple) lock,
|
||||
* we must set INTENT locks on the higher levels. The intent lock
|
||||
* detects conflicts between the low level lock and an existing high
|
||||
* level lock. For example, setting a write lock on a tuple in a
|
||||
* relation is disallowed if there is an existing read lock on the
|
||||
* entire relation. The write lock would set a WRITE + INTENT lock on
|
||||
* the relation and that lock would conflict with the read.
|
||||
*/
|
||||
switch (level)
|
||||
{
|
||||
case RELN_LEVEL:
|
||||
locks[0] = lockmode;
|
||||
locks[1] = NO_LOCK;
|
||||
locks[2] = NO_LOCK;
|
||||
break;
|
||||
case PAGE_LEVEL:
|
||||
locks[0] = lockmode + INTENT;
|
||||
locks[1] = lockmode;
|
||||
locks[2] = NO_LOCK;
|
||||
break;
|
||||
case TUPLE_LEVEL:
|
||||
locks[0] = lockmode + INTENT;
|
||||
locks[1] = lockmode + INTENT;
|
||||
locks[2] = lockmode;
|
||||
break;
|
||||
default:
|
||||
elog(ERROR, "MultiAcquire: bad lock level");
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/*
|
||||
* construct a new tag as we go. Always loop through all levels, but
|
||||
* if we arent' seting a low level lock, locks[i] is set to NO_LOCK
|
||||
* for the lower levels. Always start from the highest level and go
|
||||
* to the lowest level.
|
||||
*/
|
||||
MemSet(tmpTag, 0, sizeof(*tmpTag));
|
||||
tmpTag->relId = tag->relId;
|
||||
tmpTag->dbId = tag->dbId;
|
||||
|
||||
for (i = 0; i < N_LEVELS; i++)
|
||||
{
|
||||
if (locks[i] != NO_LOCK)
|
||||
{
|
||||
switch (i)
|
||||
{
|
||||
case RELN_LEVEL:
|
||||
/* -------------
|
||||
* Set the block # and offset to invalid
|
||||
* -------------
|
||||
*/
|
||||
BlockIdSet(&(tmpTag->tupleId.ip_blkid), InvalidBlockNumber);
|
||||
tmpTag->tupleId.ip_posid = InvalidOffsetNumber;
|
||||
break;
|
||||
case PAGE_LEVEL:
|
||||
/* -------------
|
||||
* Copy the block #, set the offset to invalid
|
||||
* -------------
|
||||
*/
|
||||
BlockIdCopy(&(tmpTag->tupleId.ip_blkid),
|
||||
&(tag->tupleId.ip_blkid));
|
||||
tmpTag->tupleId.ip_posid = InvalidOffsetNumber;
|
||||
break;
|
||||
case TUPLE_LEVEL:
|
||||
/* --------------
|
||||
* Copy the entire tuple id.
|
||||
* --------------
|
||||
*/
|
||||
ItemPointerCopy(&tmpTag->tupleId, &tag->tupleId);
|
||||
break;
|
||||
}
|
||||
|
||||
status = LockAcquire(lockmethod, tmpTag, locks[i]);
|
||||
if (!status)
|
||||
{
|
||||
|
||||
/*
|
||||
* failed for some reason. Before returning we have to
|
||||
* release all of the locks we just acquired.
|
||||
* MultiRelease(xx,xx,xx, i) means release starting from
|
||||
* the last level lock we successfully acquired
|
||||
*/
|
||||
retStatus = FALSE;
|
||||
MultiRelease(lockmethod, tag, lockmode, i);
|
||||
/* now leave the loop. Don't try for any more locks */
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return retStatus;
|
||||
}
|
||||
|
||||
/* ------------------
|
||||
* Release a page in the multi-level lock table
|
||||
* ------------------
|
||||
*/
|
||||
#ifdef NOT_USED
|
||||
bool
|
||||
MultiReleasePage(LockInfo lockinfo, ItemPointer tidPtr, LOCKMODE lockmode)
|
||||
{
|
||||
LOCKTAG tag;
|
||||
|
||||
/* ------------------
|
||||
* LOCKTAG has two bytes of padding, unfortunately. The
|
||||
* hash function will return miss if the padding bytes aren't
|
||||
* zero'd.
|
||||
* ------------------
|
||||
*/
|
||||
MemSet(&tag, 0, sizeof(LOCKTAG));
|
||||
|
||||
tag.relId = lockinfo->lockRelId.relId;
|
||||
tag.dbId = lockinfo->lockRelId.dbId;
|
||||
BlockIdCopy(&(tag.tupleId.ip_blkid), &(tidPtr->ip_blkid));
|
||||
|
||||
return MultiRelease(MultiTableId, &tag, lockmode, PAGE_LEVEL);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
/* ------------------
|
||||
* Release a relation in the multi-level lock table
|
||||
* ------------------
|
||||
*/
|
||||
bool
|
||||
MultiReleaseReln(LockInfo lockinfo, LOCKMODE lockmode)
|
||||
{
|
||||
LOCKTAG tag;
|
||||
|
||||
/* ------------------
|
||||
* LOCKTAG has two bytes of padding, unfortunately. The
|
||||
* hash function will return miss if the padding bytes aren't
|
||||
* zero'd.
|
||||
* ------------------
|
||||
*/
|
||||
MemSet(&tag, 0, sizeof(LOCKTAG));
|
||||
tag.relId = lockinfo->lockRelId.relId;
|
||||
tag.dbId = lockinfo->lockRelId.dbId;
|
||||
|
||||
return MultiRelease(MultiTableId, &tag, lockmode, RELN_LEVEL);
|
||||
}
|
||||
|
||||
/*
|
||||
* MultiRelease -- release a multi-level lock
|
||||
*
|
||||
* Returns: TRUE if successful, FALSE otherwise.
|
||||
*/
|
||||
static bool
|
||||
MultiRelease(LOCKMETHOD lockmethod,
|
||||
LOCKTAG *tag,
|
||||
LOCKMODE lockmode,
|
||||
PG_LOCK_LEVEL level)
|
||||
{
|
||||
LOCKMODE locks[N_LEVELS];
|
||||
int i,
|
||||
status;
|
||||
LOCKTAG xxTag,
|
||||
*tmpTag = &xxTag;
|
||||
|
||||
/*
|
||||
* same level scheme as MultiAcquire().
|
||||
*/
|
||||
switch (level)
|
||||
{
|
||||
case RELN_LEVEL:
|
||||
locks[0] = lockmode;
|
||||
locks[1] = NO_LOCK;
|
||||
locks[2] = NO_LOCK;
|
||||
break;
|
||||
case PAGE_LEVEL:
|
||||
locks[0] = lockmode + INTENT;
|
||||
locks[1] = lockmode;
|
||||
locks[2] = NO_LOCK;
|
||||
break;
|
||||
case TUPLE_LEVEL:
|
||||
locks[0] = lockmode + INTENT;
|
||||
locks[1] = lockmode + INTENT;
|
||||
locks[2] = lockmode;
|
||||
break;
|
||||
default:
|
||||
elog(ERROR, "MultiRelease: bad lockmode");
|
||||
}
|
||||
|
||||
/*
|
||||
* again, construct the tag on the fly. This time, however, we
|
||||
* release the locks in the REVERSE order -- from lowest level to
|
||||
* highest level.
|
||||
*
|
||||
* Must zero out the tag to set padding byes to zero and ensure hashing
|
||||
* consistency.
|
||||
*/
|
||||
MemSet(tmpTag, 0, sizeof(*tmpTag));
|
||||
tmpTag->relId = tag->relId;
|
||||
tmpTag->dbId = tag->dbId;
|
||||
|
||||
for (i = (N_LEVELS - 1); i >= 0; i--)
|
||||
{
|
||||
if (locks[i] != NO_LOCK)
|
||||
{
|
||||
switch (i)
|
||||
{
|
||||
case RELN_LEVEL:
|
||||
/* -------------
|
||||
* Set the block # and offset to invalid
|
||||
* -------------
|
||||
*/
|
||||
BlockIdSet(&(tmpTag->tupleId.ip_blkid), InvalidBlockNumber);
|
||||
tmpTag->tupleId.ip_posid = InvalidOffsetNumber;
|
||||
break;
|
||||
case PAGE_LEVEL:
|
||||
/* -------------
|
||||
* Copy the block #, set the offset to invalid
|
||||
* -------------
|
||||
*/
|
||||
BlockIdCopy(&(tmpTag->tupleId.ip_blkid),
|
||||
&(tag->tupleId.ip_blkid));
|
||||
tmpTag->tupleId.ip_posid = InvalidOffsetNumber;
|
||||
break;
|
||||
case TUPLE_LEVEL:
|
||||
ItemPointerCopy(&tmpTag->tupleId, &tag->tupleId);
|
||||
break;
|
||||
}
|
||||
status = LockRelease(lockmethod, tmpTag, locks[i]);
|
||||
if (!status)
|
||||
elog(ERROR, "MultiRelease: couldn't release after error");
|
||||
}
|
||||
}
|
||||
/* shouldn't reach here */
|
||||
return false;
|
||||
}
|
||||
@ -1,86 +0,0 @@
|
||||
/*-------------------------------------------------------------------------
|
||||
*
|
||||
* single.c
|
||||
* set single locks in the multi-level lock hierarchy
|
||||
*
|
||||
* Sometimes we don't want to set all levels of the multi-level
|
||||
* lock hierarchy at once. This allows us to set and release
|
||||
* one level at a time. It's useful in index scans when
|
||||
* you can set an intent lock at the beginning and thereafter
|
||||
* only set page locks. Tends to speed things up.
|
||||
*
|
||||
* Portions Copyright (c) 1996-2000, PostgreSQL, Inc
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/Attic/single.c,v 1.13 2000/01/26 05:57:02 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#include "postgres.h"
|
||||
|
||||
#include "storage/lmgr.h"
|
||||
#include "storage/lock.h"
|
||||
#include "storage/multilev.h"
|
||||
#include "utils/rel.h"
|
||||
|
||||
/*
|
||||
* SingleLockReln -- lock a relation
|
||||
*
|
||||
* Returns: TRUE if the lock can be set, FALSE otherwise.
|
||||
*/
|
||||
bool
|
||||
SingleLockReln(LockInfo lockinfo, LOCKMODE lockmode, int action)
|
||||
{
|
||||
LOCKTAG tag;
|
||||
|
||||
/*
|
||||
* LOCKTAG has two bytes of padding, unfortunately. The hash function
|
||||
* will return miss if the padding bytes aren't zero'd.
|
||||
*/
|
||||
MemSet(&tag, 0, sizeof(tag));
|
||||
tag.relId = lockinfo->lockRelId.relId;
|
||||
tag.dbId = lockinfo->lockRelId.dbId;
|
||||
BlockIdSet(&(tag.tupleId.ip_blkid), InvalidBlockNumber);
|
||||
tag.tupleId.ip_posid = InvalidOffsetNumber;
|
||||
|
||||
if (action == UNLOCK)
|
||||
return LockRelease(MultiTableId, &tag, lockmode);
|
||||
else
|
||||
return LockAcquire(MultiTableId, &tag, lockmode);
|
||||
}
|
||||
|
||||
/*
|
||||
* SingleLockPage -- use multi-level lock table, but lock
|
||||
* only at the page level.
|
||||
*
|
||||
* Assumes that an INTENT lock has already been set in the
|
||||
* multi-level lock table.
|
||||
*
|
||||
*/
|
||||
bool
|
||||
SingleLockPage(LockInfo lockinfo,
|
||||
ItemPointer tidPtr,
|
||||
LOCKMODE lockmode,
|
||||
int action)
|
||||
{
|
||||
LOCKTAG tag;
|
||||
|
||||
/*
|
||||
* LOCKTAG has two bytes of padding, unfortunately. The hash function
|
||||
* will return miss if the padding bytes aren't zero'd.
|
||||
*/
|
||||
MemSet(&tag, 0, sizeof(tag));
|
||||
tag.relId = lockinfo->lockRelId.relId;
|
||||
tag.dbId = lockinfo->lockRelId.dbId;
|
||||
BlockIdCopy(&(tag.tupleId.ip_blkid), &(tidPtr->ip_blkid));
|
||||
tag.tupleId.ip_posid = InvalidOffsetNumber;
|
||||
|
||||
|
||||
if (action == UNLOCK)
|
||||
return LockRelease(MultiTableId, &tag, lockmode);
|
||||
else
|
||||
return LockAcquire(MultiTableId, &tag, lockmode);
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user