From e6e9e18e9ed17a5070c996881ec5e3deb8c31324 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Wed, 20 Dec 2000 22:54:02 +0000 Subject: [PATCH] Remove multi.c and single.c, which have been dead code for over two years. --- src/backend/storage/lmgr/multi.c | 453 -------------------------------------- src/backend/storage/lmgr/single.c | 86 -------- 2 files changed, 539 deletions(-) delete mode 100644 src/backend/storage/lmgr/multi.c delete mode 100644 src/backend/storage/lmgr/single.c diff --git a/src/backend/storage/lmgr/multi.c b/src/backend/storage/lmgr/multi.c deleted file mode 100644 index a1738e4ca8..0000000000 --- a/src/backend/storage/lmgr/multi.c +++ /dev/null @@ -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; -} diff --git a/src/backend/storage/lmgr/single.c b/src/backend/storage/lmgr/single.c deleted file mode 100644 index 44c0875de6..0000000000 --- a/src/backend/storage/lmgr/single.c +++ /dev/null @@ -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); -} -- 2.11.0