predicate.c File Reference

#include "postgres.h"
#include "access/parallel.h"
#include "access/slru.h"
#include "access/transam.h"
#include "access/twophase.h"
#include "access/twophase_rmgr.h"
#include "access/xact.h"
#include "access/xlog.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "port/pg_lfind.h"
#include "storage/predicate.h"
#include "storage/predicate_internals.h"
#include "storage/proc.h"
#include "storage/procarray.h"
#include "utils/guc_hooks.h"
#include "utils/rel.h"
#include "utils/snapmgr.h"

Include dependency graph for predicate.c:

Go to the source code of this file.

Data Structures
struct	SerialControlData

Macros
#define	TargetTagIsCoveredBy(covered_target, covering_target)
#define	PredicateLockHashPartition(hashcode)    ((hashcode) % NUM_PREDICATELOCK_PARTITIONS)
#define	PredicateLockHashPartitionLock(hashcode)
#define	PredicateLockHashPartitionLockByIndex(i)    (&MainLWLockArray[PREDICATELOCK_MANAGER_LWLOCK_OFFSET + (i)].lock)
#define	NPREDICATELOCKTARGETENTS()    mul_size(max_predicate_locks_per_xact, add_size(MaxBackends, max_prepared_xacts))
#define	SxactIsOnFinishedList(sxact)   (!dlist_node_is_detached(&(sxact)->finishedLink))
#define	SxactIsCommitted(sxact)   (((sxact)->flags & SXACT_FLAG_COMMITTED) != 0)
#define	SxactIsPrepared(sxact)   (((sxact)->flags & SXACT_FLAG_PREPARED) != 0)
#define	SxactIsRolledBack(sxact)   (((sxact)->flags & SXACT_FLAG_ROLLED_BACK) != 0)
#define	SxactIsDoomed(sxact)   (((sxact)->flags & SXACT_FLAG_DOOMED) != 0)
#define	SxactIsReadOnly(sxact)   (((sxact)->flags & SXACT_FLAG_READ_ONLY) != 0)
#define	SxactHasSummaryConflictIn(sxact)   (((sxact)->flags & SXACT_FLAG_SUMMARY_CONFLICT_IN) != 0)
#define	SxactHasSummaryConflictOut(sxact)   (((sxact)->flags & SXACT_FLAG_SUMMARY_CONFLICT_OUT) != 0)
#define	SxactHasConflictOut(sxact)   (((sxact)->flags & SXACT_FLAG_CONFLICT_OUT) != 0)
#define	SxactIsDeferrableWaiting(sxact)   (((sxact)->flags & SXACT_FLAG_DEFERRABLE_WAITING) != 0)
#define	SxactIsROSafe(sxact)   (((sxact)->flags & SXACT_FLAG_RO_SAFE) != 0)
#define	SxactIsROUnsafe(sxact)   (((sxact)->flags & SXACT_FLAG_RO_UNSAFE) != 0)
#define	SxactIsPartiallyReleased(sxact)   (((sxact)->flags & SXACT_FLAG_PARTIALLY_RELEASED) != 0)
#define	PredicateLockTargetTagHashCode(predicatelocktargettag)    get_hash_value(PredicateLockTargetHash, predicatelocktargettag)
#define	PredicateLockHashCodeFromTargetHashCode(predicatelocktag, targethash)
#define	SerialSlruCtl   (&SerialSlruCtlData)
#define	SERIAL_PAGESIZE   BLCKSZ
#define	SERIAL_ENTRYSIZE   sizeof(SerCommitSeqNo)
#define	SERIAL_ENTRIESPERPAGE   (SERIAL_PAGESIZE / SERIAL_ENTRYSIZE)
#define	SERIAL_MAX_PAGE   (MaxTransactionId / SERIAL_ENTRIESPERPAGE)
#define	SerialNextPage(page)   (((page) >= SERIAL_MAX_PAGE) ? 0 : (page) + 1)
#define	SerialValue(slotno, xid)
#define	SerialPage(xid)   (((uint32) (xid)) / SERIAL_ENTRIESPERPAGE)

Typedefs
typedef struct SerialControlData	SerialControlData
typedef struct SerialControlData *	SerialControl

Functions
static SERIALIZABLEXACT *	CreatePredXact (void)
static void	ReleasePredXact (SERIALIZABLEXACT *sxact)
static bool	RWConflictExists (const SERIALIZABLEXACT *reader, const SERIALIZABLEXACT *writer)
static void	SetRWConflict (SERIALIZABLEXACT *reader, SERIALIZABLEXACT *writer)
static void	SetPossibleUnsafeConflict (SERIALIZABLEXACT *roXact, SERIALIZABLEXACT *activeXact)
static void	ReleaseRWConflict (RWConflict conflict)
static void	FlagSxactUnsafe (SERIALIZABLEXACT *sxact)
static bool	SerialPagePrecedesLogically (int64 page1, int64 page2)
static void	SerialInit (void)
static void	SerialAdd (TransactionId xid, SerCommitSeqNo minConflictCommitSeqNo)
static SerCommitSeqNo	SerialGetMinConflictCommitSeqNo (TransactionId xid)
static void	SerialSetActiveSerXmin (TransactionId xid)
static uint32	predicatelock_hash (const void *key, Size keysize)
static void	SummarizeOldestCommittedSxact (void)
static Snapshot	GetSafeSnapshot (Snapshot origSnapshot)
static Snapshot	GetSerializableTransactionSnapshotInt (Snapshot snapshot, VirtualTransactionId *sourcevxid, int sourcepid)
static bool	PredicateLockExists (const PREDICATELOCKTARGETTAG *targettag)
static bool	GetParentPredicateLockTag (const PREDICATELOCKTARGETTAG *tag, PREDICATELOCKTARGETTAG *parent)
static bool	CoarserLockCovers (const PREDICATELOCKTARGETTAG *newtargettag)
static void	RemoveScratchTarget (bool lockheld)
static void	RestoreScratchTarget (bool lockheld)
static void	RemoveTargetIfNoLongerUsed (PREDICATELOCKTARGET *target, uint32 targettaghash)
static void	DeleteChildTargetLocks (const PREDICATELOCKTARGETTAG *newtargettag)
static int	MaxPredicateChildLocks (const PREDICATELOCKTARGETTAG *tag)
static bool	CheckAndPromotePredicateLockRequest (const PREDICATELOCKTARGETTAG *reqtag)
static void	DecrementParentLocks (const PREDICATELOCKTARGETTAG *targettag)
static void	CreatePredicateLock (const PREDICATELOCKTARGETTAG *targettag, uint32 targettaghash, SERIALIZABLEXACT *sxact)
static void	DeleteLockTarget (PREDICATELOCKTARGET *target, uint32 targettaghash)
static bool	TransferPredicateLocksToNewTarget (PREDICATELOCKTARGETTAG oldtargettag, PREDICATELOCKTARGETTAG newtargettag, bool removeOld)
static void	PredicateLockAcquire (const PREDICATELOCKTARGETTAG *targettag)
static void	DropAllPredicateLocksFromTable (Relation relation, bool transfer)
static void	SetNewSxactGlobalXmin (void)
static void	ClearOldPredicateLocks (void)
static void	ReleaseOneSerializableXact (SERIALIZABLEXACT *sxact, bool partial, bool summarize)
static bool	XidIsConcurrent (TransactionId xid)
static void	CheckTargetForConflictsIn (PREDICATELOCKTARGETTAG *targettag)
static void	FlagRWConflict (SERIALIZABLEXACT *reader, SERIALIZABLEXACT *writer)
static void	OnConflict_CheckForSerializationFailure (const SERIALIZABLEXACT *reader, SERIALIZABLEXACT *writer)
static void	CreateLocalPredicateLockHash (void)
static void	ReleasePredicateLocksLocal (void)
static bool	PredicateLockingNeededForRelation (Relation relation)
static bool	SerializationNeededForRead (Relation relation, Snapshot snapshot)
static bool	SerializationNeededForWrite (Relation relation)
bool	check_serial_buffers (int *newval, void **extra, GucSource source)
void	CheckPointPredicate (void)
void	PredicateLockShmemInit (void)
Size	PredicateLockShmemSize (void)
PredicateLockData *	GetPredicateLockStatusData (void)
int	GetSafeSnapshotBlockingPids (int blocked_pid, int *output, int output_size)
Snapshot	GetSerializableTransactionSnapshot (Snapshot snapshot)
void	SetSerializableTransactionSnapshot (Snapshot snapshot, VirtualTransactionId *sourcevxid, int sourcepid)
void	RegisterPredicateLockingXid (TransactionId xid)
bool	PageIsPredicateLocked (Relation relation, BlockNumber blkno)
void	PredicateLockRelation (Relation relation, Snapshot snapshot)
void	PredicateLockPage (Relation relation, BlockNumber blkno, Snapshot snapshot)
void	PredicateLockTID (Relation relation, ItemPointer tid, Snapshot snapshot, TransactionId tuple_xid)
void	TransferPredicateLocksToHeapRelation (Relation relation)
void	PredicateLockPageSplit (Relation relation, BlockNumber oldblkno, BlockNumber newblkno)
void	PredicateLockPageCombine (Relation relation, BlockNumber oldblkno, BlockNumber newblkno)
void	ReleasePredicateLocks (bool isCommit, bool isReadOnlySafe)
bool	CheckForSerializableConflictOutNeeded (Relation relation, Snapshot snapshot)
void	CheckForSerializableConflictOut (Relation relation, TransactionId xid, Snapshot snapshot)
void	CheckForSerializableConflictIn (Relation relation, ItemPointer tid, BlockNumber blkno)
void	CheckTableForSerializableConflictIn (Relation relation)
void	PreCommit_CheckForSerializationFailure (void)
void	AtPrepare_PredicateLocks (void)
void	PostPrepare_PredicateLocks (TransactionId xid)
void	PredicateLockTwoPhaseFinish (TransactionId xid, bool isCommit)
void	predicatelock_twophase_recover (TransactionId xid, uint16 info, void *recdata, uint32 len)
SerializableXactHandle	ShareSerializableXact (void)
void	AttachSerializableXact (SerializableXactHandle handle)

Variables
static SlruCtlData	SerialSlruCtlData
static SerialControl	serialControl
static SERIALIZABLEXACT *	OldCommittedSxact
int	max_predicate_locks_per_xact
int	max_predicate_locks_per_relation
int	max_predicate_locks_per_page
static PredXactList	PredXact
static RWConflictPoolHeader	RWConflictPool
static HTAB *	SerializableXidHash
static HTAB *	PredicateLockTargetHash
static HTAB *	PredicateLockHash
static dlist_head *	FinishedSerializableTransactions
static const PREDICATELOCKTARGETTAG	ScratchTargetTag = {0, 0, 0, 0}
static uint32	ScratchTargetTagHash
static LWLock *	ScratchPartitionLock
static HTAB *	LocalPredicateLockHash = NULL
static SERIALIZABLEXACT *	MySerializableXact = InvalidSerializableXact
static bool	MyXactDidWrite = false
static SERIALIZABLEXACT *	SavedSerializableXact = InvalidSerializableXact

Macro Definition Documentation

NPREDICATELOCKTARGETENTS

#define NPREDICATELOCKTARGETENTS

(

)

mul_size(max_predicate_locks_per_xact, add_size(MaxBackends, max_prepared_xacts))

Definition at line 264 of file predicate.c.

PredicateLockHashCodeFromTargetHashCode

#define PredicateLockHashCodeFromTargetHashCode	(		predicatelocktag,
			targethash
	)

Value:

    ((targethash) ^ ((uint32) PointerGetDatum((predicatelocktag)->myXact)) \
     << LOG2_NUM_PREDICATELOCK_PARTITIONS)

Definition at line 316 of file predicate.c.

PredicateLockHashPartition

#define PredicateLockHashPartition

(

hashcode

)

((hashcode) % NUM_PREDICATELOCK_PARTITIONS)

Definition at line 256 of file predicate.c.

PredicateLockHashPartitionLock

#define PredicateLockHashPartitionLock

(

hashcode

)

Value:

    (&MainLWLockArray[PREDICATELOCK_MANAGER_LWLOCK_OFFSET + \
        PredicateLockHashPartition(hashcode)].lock)

Definition at line 258 of file predicate.c.

PredicateLockHashPartitionLockByIndex

#define PredicateLockHashPartitionLockByIndex

(

i

)

(&MainLWLockArray[PREDICATELOCK_MANAGER_LWLOCK_OFFSET + (i)].lock)

Definition at line 261 of file predicate.c.

PredicateLockTargetTagHashCode

#define PredicateLockTargetTagHashCode

(

predicatelocktargettag

)

get_hash_value(PredicateLockTargetHash, predicatelocktargettag)

Definition at line 303 of file predicate.c.

SERIAL_ENTRIESPERPAGE

#define SERIAL_ENTRIESPERPAGE   (SERIAL_PAGESIZE / SERIAL_ENTRYSIZE)

Definition at line 330 of file predicate.c.

SERIAL_ENTRYSIZE

#define SERIAL_ENTRYSIZE   sizeof(SerCommitSeqNo)

Definition at line 329 of file predicate.c.

SERIAL_MAX_PAGE

#define SERIAL_MAX_PAGE   (MaxTransactionId / SERIAL_ENTRIESPERPAGE)

Definition at line 335 of file predicate.c.

SERIAL_PAGESIZE

#define SERIAL_PAGESIZE   BLCKSZ

Definition at line 328 of file predicate.c.

SerialNextPage

#define SerialNextPage

(

page

)

(((page) >= SERIAL_MAX_PAGE) ? 0 : (page) + 1)

Definition at line 337 of file predicate.c.

SerialPage

#define SerialPage

(

xid

)

(((uint32) (xid)) / SERIAL_ENTRIESPERPAGE)

Definition at line 343 of file predicate.c.

SerialSlruCtl

#define SerialSlruCtl   (&SerialSlruCtlData)

Definition at line 326 of file predicate.c.

SerialValue

#define SerialValue	(		slotno,
			xid
	)

Value:

    (*((SerCommitSeqNo *) \
    (SerialSlruCtl->shared->page_buffer[slotno] + \
    ((((uint32) (xid)) % SERIAL_ENTRIESPERPAGE) * SERIAL_ENTRYSIZE))))

Definition at line 339 of file predicate.c.

SxactHasConflictOut

#define SxactHasConflictOut

(

sxact

)

(((sxact)->flags & SXACT_FLAG_CONFLICT_OUT) != 0)

Definition at line 289 of file predicate.c.

SxactHasSummaryConflictIn

#define SxactHasSummaryConflictIn

(

sxact

)

(((sxact)->flags & SXACT_FLAG_SUMMARY_CONFLICT_IN) != 0)

Definition at line 282 of file predicate.c.

SxactHasSummaryConflictOut

#define SxactHasSummaryConflictOut

(

sxact

)

(((sxact)->flags & SXACT_FLAG_SUMMARY_CONFLICT_OUT) != 0)

Definition at line 283 of file predicate.c.

SxactIsCommitted

#define SxactIsCommitted

(

sxact

)

(((sxact)->flags & SXACT_FLAG_COMMITTED) != 0)

Definition at line 277 of file predicate.c.

SxactIsDeferrableWaiting

#define SxactIsDeferrableWaiting

(

sxact

)

(((sxact)->flags & SXACT_FLAG_DEFERRABLE_WAITING) != 0)

Definition at line 290 of file predicate.c.

SxactIsDoomed

#define SxactIsDoomed

(

sxact

)

(((sxact)->flags & SXACT_FLAG_DOOMED) != 0)

Definition at line 280 of file predicate.c.

SxactIsOnFinishedList

#define SxactIsOnFinishedList

(

sxact

)

(!dlist_node_is_detached(&(sxact)->finishedLink))

Definition at line 267 of file predicate.c.

SxactIsPartiallyReleased

#define SxactIsPartiallyReleased

(

sxact

)

(((sxact)->flags & SXACT_FLAG_PARTIALLY_RELEASED) != 0)

Definition at line 293 of file predicate.c.

SxactIsPrepared

#define SxactIsPrepared

(

sxact

)

(((sxact)->flags & SXACT_FLAG_PREPARED) != 0)

Definition at line 278 of file predicate.c.

SxactIsReadOnly

#define SxactIsReadOnly

(

sxact

)

(((sxact)->flags & SXACT_FLAG_READ_ONLY) != 0)

Definition at line 281 of file predicate.c.

SxactIsRolledBack

#define SxactIsRolledBack

(

sxact

)

(((sxact)->flags & SXACT_FLAG_ROLLED_BACK) != 0)

Definition at line 279 of file predicate.c.

SxactIsROSafe

#define SxactIsROSafe

(

sxact

)

(((sxact)->flags & SXACT_FLAG_RO_SAFE) != 0)

Definition at line 291 of file predicate.c.

SxactIsROUnsafe

#define SxactIsROUnsafe

(

sxact

)

(((sxact)->flags & SXACT_FLAG_RO_UNSAFE) != 0)

Definition at line 292 of file predicate.c.

TargetTagIsCoveredBy

#define TargetTagIsCoveredBy	(		covered_target,
			covering_target
	)

Value:

    ((GET_PREDICATELOCKTARGETTAG_RELATION(covered_target) == /* (2) */  \
      GET_PREDICATELOCKTARGETTAG_RELATION(covering_target))             \
     && (GET_PREDICATELOCKTARGETTAG_OFFSET(covering_target) ==          \
         InvalidOffsetNumber)                                /* (3) */  \
     && (((GET_PREDICATELOCKTARGETTAG_OFFSET(covered_target) !=         \
           InvalidOffsetNumber)                              /* (4a) */ \
          && (GET_PREDICATELOCKTARGETTAG_PAGE(covering_target) ==       \
              GET_PREDICATELOCKTARGETTAG_PAGE(covered_target)))         \
         || ((GET_PREDICATELOCKTARGETTAG_PAGE(covering_target) ==       \
              InvalidBlockNumber)                            /* (4b) */ \
             && (GET_PREDICATELOCKTARGETTAG_PAGE(covered_target)        \
                 != InvalidBlockNumber)))                               \
     && (GET_PREDICATELOCKTARGETTAG_DB(covered_target) ==    /* (1) */  \
         GET_PREDICATELOCKTARGETTAG_DB(covering_target)))

Definition at line 233 of file predicate.c.

Typedef Documentation

SerialControl

typedef struct SerialControlData* SerialControl

Definition at line 352 of file predicate.c.

SerialControlData

typedef struct SerialControlData SerialControlData

Function Documentation

AtPrepare_PredicateLocks()

void AtPrepare_PredicateLocks

(

void

)

Definition at line 4775 of file predicate.c.

{
    SERIALIZABLEXACT *sxact;
    TwoPhasePredicateRecord record;
    TwoPhasePredicateXactRecord *xactRecord;
    TwoPhasePredicateLockRecord *lockRecord;
    dlist_iter  iter;
 
    sxact = MySerializableXact;
    xactRecord = &(record.data.xactRecord);
    lockRecord = &(record.data.lockRecord);
 
    if (MySerializableXact == InvalidSerializableXact)
        return;
 
    /* Generate an xact record for our SERIALIZABLEXACT */
    record.type = TWOPHASEPREDICATERECORD_XACT;
    xactRecord->xmin = MySerializableXact->xmin;
    xactRecord->flags = MySerializableXact->flags;
 
    /*
     * Note that we don't include the list of conflicts in our out in the
     * statefile, because new conflicts can be added even after the
     * transaction prepares. We'll just make a conservative assumption during
     * recovery instead.
     */
 
    RegisterTwoPhaseRecord(TWOPHASE_RM_PREDICATELOCK_ID, 0,
                           &record, sizeof(record));
 
    /*
     * Generate a lock record for each lock.
     *
     * To do this, we need to walk the predicate lock list in our sxact rather
     * than using the local predicate lock table because the latter is not
     * guaranteed to be accurate.
     */
    LWLockAcquire(SerializablePredicateListLock, LW_SHARED);
 
    /*
     * No need to take sxact->perXactPredicateListLock in parallel mode
     * because there cannot be any parallel workers running while we are
     * preparing a transaction.
     */
    Assert(!IsParallelWorker() && !ParallelContextActive());
 
    dlist_foreach(iter, &sxact->predicateLocks)
    {
        PREDICATELOCK *predlock =
            dlist_container(PREDICATELOCK, xactLink, iter.cur);
 
        record.type = TWOPHASEPREDICATERECORD_LOCK;
        lockRecord->target = predlock->tag.myTarget->tag;
 
        RegisterTwoPhaseRecord(TWOPHASE_RM_PREDICATELOCK_ID, 0,
                               &record, sizeof(record));
    }
 
    LWLockRelease(SerializablePredicateListLock);
}

References Assert, dlist_iter::cur, TwoPhasePredicateRecord::data, dlist_container, dlist_foreach, SERIALIZABLEXACT::flags, TwoPhasePredicateXactRecord::flags, InvalidSerializableXact, IsParallelWorker, TwoPhasePredicateRecord::lockRecord, LW_SHARED, LWLockAcquire(), LWLockRelease(), MySerializableXact, PREDICATELOCKTAG::myTarget, ParallelContextActive(), SERIALIZABLEXACT::predicateLocks, RegisterTwoPhaseRecord(), PREDICATELOCKTARGET::tag, PREDICATELOCK::tag, TwoPhasePredicateLockRecord::target, TWOPHASE_RM_PREDICATELOCK_ID, TWOPHASEPREDICATERECORD_LOCK, TWOPHASEPREDICATERECORD_XACT, TwoPhasePredicateRecord::type, TwoPhasePredicateRecord::xactRecord, SERIALIZABLEXACT::xmin, and TwoPhasePredicateXactRecord::xmin.

Referenced by PrepareTransaction().

AttachSerializableXact()

void AttachSerializableXact

(

SerializableXactHandle

handle

)

Definition at line 5040 of file predicate.c.

{
 
    Assert(MySerializableXact == InvalidSerializableXact);
 
    MySerializableXact = (SERIALIZABLEXACT *) handle;
    if (MySerializableXact != InvalidSerializableXact)
        CreateLocalPredicateLockHash();
}

References Assert, CreateLocalPredicateLockHash(), InvalidSerializableXact, and MySerializableXact.

Referenced by ParallelWorkerMain().

check_serial_buffers()

bool check_serial_buffers	(	int *	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 847 of file predicate.c.

{
    return check_slru_buffers("serializable_buffers", newval);
}

References check_slru_buffers(), and newval.

CheckAndPromotePredicateLockRequest()

static bool CheckAndPromotePredicateLockRequest ( const PREDICATELOCKTARGETTAG *  reqtag )

static

Definition at line 2311 of file predicate.c.

{
    PREDICATELOCKTARGETTAG targettag,
                nexttag,
                promotiontag;
    LOCALPREDICATELOCK *parentlock;
    bool        found,
                promote;
 
    promote = false;
 
    targettag = *reqtag;
 
    /* check parents iteratively */
    while (GetParentPredicateLockTag(&targettag, &nexttag))
    {
        targettag = nexttag;
        parentlock = (LOCALPREDICATELOCK *) hash_search(LocalPredicateLockHash,
                                                        &targettag,
                                                        HASH_ENTER,
                                                        &found);
        if (!found)
        {
            parentlock->held = false;
            parentlock->childLocks = 1;
        }
        else
            parentlock->childLocks++;
 
        if (parentlock->childLocks >
            MaxPredicateChildLocks(&targettag))
        {
            /*
             * We should promote to this parent lock. Continue to check its
             * ancestors, however, both to get their child counts right and to
             * check whether we should just go ahead and promote to one of
             * them.
             */
            promotiontag = targettag;
            promote = true;
        }
    }
 
    if (promote)
    {
        /* acquire coarsest ancestor eligible for promotion */
        PredicateLockAcquire(&promotiontag);
        return true;
    }
    else
        return false;
}

References LOCALPREDICATELOCK::childLocks, GetParentPredicateLockTag(), HASH_ENTER, hash_search(), LOCALPREDICATELOCK::held, LocalPredicateLockHash, MaxPredicateChildLocks(), and PredicateLockAcquire().

Referenced by PredicateLockAcquire().

CheckForSerializableConflictIn()

void CheckForSerializableConflictIn	(	Relation	relation,
		ItemPointer	tid,
		BlockNumber	blkno
	)

Definition at line 4321 of file predicate.c.

{
    PREDICATELOCKTARGETTAG targettag;
 
    if (!SerializationNeededForWrite(relation))
        return;
 
    /* Check if someone else has already decided that we need to die */
    if (SxactIsDoomed(MySerializableXact))
        ereport(ERROR,
                (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
                 errmsg("could not serialize access due to read/write dependencies among transactions"),
                 errdetail_internal("Reason code: Canceled on identification as a pivot, during conflict in checking."),
                 errhint("The transaction might succeed if retried.")));
 
    /*
     * We're doing a write which might cause rw-conflicts now or later.
     * Memorize that fact.
     */
    MyXactDidWrite = true;
 
    /*
     * It is important that we check for locks from the finest granularity to
     * the coarsest granularity, so that granularity promotion doesn't cause
     * us to miss a lock.  The new (coarser) lock will be acquired before the
     * old (finer) locks are released.
     *
     * It is not possible to take and hold a lock across the checks for all
     * granularities because each target could be in a separate partition.
     */
    if (tid != NULL)
    {
        SET_PREDICATELOCKTARGETTAG_TUPLE(targettag,
                                         relation->rd_locator.dbOid,
                                         relation->rd_id,
                                         ItemPointerGetBlockNumber(tid),
                                         ItemPointerGetOffsetNumber(tid));
        CheckTargetForConflictsIn(&targettag);
    }
 
    if (blkno != InvalidBlockNumber)
    {
        SET_PREDICATELOCKTARGETTAG_PAGE(targettag,
                                        relation->rd_locator.dbOid,
                                        relation->rd_id,
                                        blkno);
        CheckTargetForConflictsIn(&targettag);
    }
 
    SET_PREDICATELOCKTARGETTAG_RELATION(targettag,
                                        relation->rd_locator.dbOid,
                                        relation->rd_id);
    CheckTargetForConflictsIn(&targettag);
}

References CheckTargetForConflictsIn(), RelFileLocator::dbOid, ereport, errcode(), ERRCODE_T_R_SERIALIZATION_FAILURE, errdetail_internal(), errhint(), errmsg(), ERROR, InvalidBlockNumber, ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), MySerializableXact, MyXactDidWrite, RelationData::rd_id, RelationData::rd_locator, SerializationNeededForWrite(), SET_PREDICATELOCKTARGETTAG_PAGE, SET_PREDICATELOCKTARGETTAG_RELATION, SET_PREDICATELOCKTARGETTAG_TUPLE, and SxactIsDoomed.

Referenced by _bt_check_unique(), _bt_doinsert(), _hash_doinsert(), ginEntryInsert(), ginFindLeafPage(), ginHeapTupleFastInsert(), gistinserttuples(), heap_delete(), heap_insert(), heap_multi_insert(), heap_update(), and index_insert().

CheckForSerializableConflictOut()

void CheckForSerializableConflictOut	(	Relation	relation,
		TransactionId	xid,
		Snapshot	snapshot
	)

Definition at line 4008 of file predicate.c.

{
    SERIALIZABLEXIDTAG sxidtag;
    SERIALIZABLEXID *sxid;
    SERIALIZABLEXACT *sxact;
 
    if (!SerializationNeededForRead(relation, snapshot))
        return;
 
    /* Check if someone else has already decided that we need to die */
    if (SxactIsDoomed(MySerializableXact))
    {
        ereport(ERROR,
                (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
                 errmsg("could not serialize access due to read/write dependencies among transactions"),
                 errdetail_internal("Reason code: Canceled on identification as a pivot, during conflict out checking."),
                 errhint("The transaction might succeed if retried.")));
    }
    Assert(TransactionIdIsValid(xid));
 
    if (TransactionIdEquals(xid, GetTopTransactionIdIfAny()))
        return;
 
    /*
     * Find sxact or summarized info for the top level xid.
     */
    sxidtag.xid = xid;
    LWLockAcquire(SerializableXactHashLock, LW_EXCLUSIVE);
    sxid = (SERIALIZABLEXID *)
        hash_search(SerializableXidHash, &sxidtag, HASH_FIND, NULL);
    if (!sxid)
    {
        /*
         * Transaction not found in "normal" SSI structures.  Check whether it
         * got pushed out to SLRU storage for "old committed" transactions.
         */
        SerCommitSeqNo conflictCommitSeqNo;
 
        conflictCommitSeqNo = SerialGetMinConflictCommitSeqNo(xid);
        if (conflictCommitSeqNo != 0)
        {
            if (conflictCommitSeqNo != InvalidSerCommitSeqNo
                && (!SxactIsReadOnly(MySerializableXact)
                    || conflictCommitSeqNo
                    <= MySerializableXact->SeqNo.lastCommitBeforeSnapshot))
                ereport(ERROR,
                        (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
                         errmsg("could not serialize access due to read/write dependencies among transactions"),
                         errdetail_internal("Reason code: Canceled on conflict out to old pivot %u.", xid),
                         errhint("The transaction might succeed if retried.")));
 
            if (SxactHasSummaryConflictIn(MySerializableXact)
                || !dlist_is_empty(&MySerializableXact->inConflicts))
                ereport(ERROR,
                        (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
                         errmsg("could not serialize access due to read/write dependencies among transactions"),
                         errdetail_internal("Reason code: Canceled on identification as a pivot, with conflict out to old committed transaction %u.", xid),
                         errhint("The transaction might succeed if retried.")));
 
            MySerializableXact->flags |= SXACT_FLAG_SUMMARY_CONFLICT_OUT;
        }
 
        /* It's not serializable or otherwise not important. */
        LWLockRelease(SerializableXactHashLock);
        return;
    }
    sxact = sxid->myXact;
    Assert(TransactionIdEquals(sxact->topXid, xid));
    if (sxact == MySerializableXact || SxactIsDoomed(sxact))
    {
        /* Can't conflict with ourself or a transaction that will roll back. */
        LWLockRelease(SerializableXactHashLock);
        return;
    }
 
    /*
     * We have a conflict out to a transaction which has a conflict out to a
     * summarized transaction.  That summarized transaction must have
     * committed first, and we can't tell when it committed in relation to our
     * snapshot acquisition, so something needs to be canceled.
     */
    if (SxactHasSummaryConflictOut(sxact))
    {
        if (!SxactIsPrepared(sxact))
        {
            sxact->flags |= SXACT_FLAG_DOOMED;
            LWLockRelease(SerializableXactHashLock);
            return;
        }
        else
        {
            LWLockRelease(SerializableXactHashLock);
            ereport(ERROR,
                    (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
                     errmsg("could not serialize access due to read/write dependencies among transactions"),
                     errdetail_internal("Reason code: Canceled on conflict out to old pivot."),
                     errhint("The transaction might succeed if retried.")));
        }
    }
 
    /*
     * If this is a read-only transaction and the writing transaction has
     * committed, and it doesn't have a rw-conflict to a transaction which
     * committed before it, no conflict.
     */
    if (SxactIsReadOnly(MySerializableXact)
        && SxactIsCommitted(sxact)
        && !SxactHasSummaryConflictOut(sxact)
        && (!SxactHasConflictOut(sxact)
            || MySerializableXact->SeqNo.lastCommitBeforeSnapshot < sxact->SeqNo.earliestOutConflictCommit))
    {
        /* Read-only transaction will appear to run first.  No conflict. */
        LWLockRelease(SerializableXactHashLock);
        return;
    }
 
    if (!XidIsConcurrent(xid))
    {
        /* This write was already in our snapshot; no conflict. */
        LWLockRelease(SerializableXactHashLock);
        return;
    }
 
    if (RWConflictExists(MySerializableXact, sxact))
    {
        /* We don't want duplicate conflict records in the list. */
        LWLockRelease(SerializableXactHashLock);
        return;
    }
 
    /*
     * Flag the conflict.  But first, if this conflict creates a dangerous
     * structure, ereport an error.
     */
    FlagRWConflict(MySerializableXact, sxact);
    LWLockRelease(SerializableXactHashLock);
}

References Assert, dlist_is_empty(), SERIALIZABLEXACT::earliestOutConflictCommit, ereport, errcode(), ERRCODE_T_R_SERIALIZATION_FAILURE, errdetail_internal(), errhint(), errmsg(), ERROR, FlagRWConflict(), SERIALIZABLEXACT::flags, GetTopTransactionIdIfAny(), HASH_FIND, hash_search(), SERIALIZABLEXACT::inConflicts, InvalidSerCommitSeqNo, SERIALIZABLEXACT::lastCommitBeforeSnapshot, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MySerializableXact, SERIALIZABLEXID::myXact, RWConflictExists(), SERIALIZABLEXACT::SeqNo, SerialGetMinConflictCommitSeqNo(), SerializableXidHash, SerializationNeededForRead(), SXACT_FLAG_DOOMED, SXACT_FLAG_SUMMARY_CONFLICT_OUT, SxactHasConflictOut, SxactHasSummaryConflictIn, SxactHasSummaryConflictOut, SxactIsCommitted, SxactIsDoomed, SxactIsPrepared, SxactIsReadOnly, SERIALIZABLEXACT::topXid, TransactionIdEquals, TransactionIdIsValid, SERIALIZABLEXIDTAG::xid, and XidIsConcurrent().

Referenced by HeapCheckForSerializableConflictOut().

CheckForSerializableConflictOutNeeded()

bool CheckForSerializableConflictOutNeeded	(	Relation	relation,
		Snapshot	snapshot
	)

Definition at line 3976 of file predicate.c.

{
    if (!SerializationNeededForRead(relation, snapshot))
        return false;
 
    /* Check if someone else has already decided that we need to die */
    if (SxactIsDoomed(MySerializableXact))
    {
        ereport(ERROR,
                (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
                 errmsg("could not serialize access due to read/write dependencies among transactions"),
                 errdetail_internal("Reason code: Canceled on identification as a pivot, during conflict out checking."),
                 errhint("The transaction might succeed if retried.")));
    }
 
    return true;
}

References ereport, errcode(), ERRCODE_T_R_SERIALIZATION_FAILURE, errdetail_internal(), errhint(), errmsg(), ERROR, MySerializableXact, SerializationNeededForRead(), and SxactIsDoomed.

Referenced by heap_prepare_pagescan(), and HeapCheckForSerializableConflictOut().

CheckPointPredicate()

void CheckPointPredicate

(

void

)

Definition at line 1036 of file predicate.c.

{
    int64       truncateCutoffPage;
 
    LWLockAcquire(SerialControlLock, LW_EXCLUSIVE);
 
    /* Exit quickly if the SLRU is currently not in use. */
    if (serialControl->headPage < 0)
    {
        LWLockRelease(SerialControlLock);
        return;
    }
 
    if (TransactionIdIsValid(serialControl->tailXid))
    {
        int64       tailPage;
 
        tailPage = SerialPage(serialControl->tailXid);
 
        /*
         * It is possible for the tailXid to be ahead of the headXid.  This
         * occurs if we checkpoint while there are in-progress serializable
         * transaction(s) advancing the tail but we are yet to summarize the
         * transactions.  In this case, we cutoff up to the headPage and the
         * next summary will advance the headXid.
         */
        if (SerialPagePrecedesLogically(tailPage, serialControl->headPage))
        {
            /* We can truncate the SLRU up to the page containing tailXid */
            truncateCutoffPage = tailPage;
        }
        else
            truncateCutoffPage = serialControl->headPage;
    }
    else
    {
        /*----------
         * The SLRU is no longer needed. Truncate to head before we set head
         * invalid.
         *
         * XXX: It's possible that the SLRU is not needed again until XID
         * wrap-around has happened, so that the segment containing headPage
         * that we leave behind will appear to be new again. In that case it
         * won't be removed until XID horizon advances enough to make it
         * current again.
         *
         * XXX: This should happen in vac_truncate_clog(), not in checkpoints.
         * Consider this scenario, starting from a system with no in-progress
         * transactions and VACUUM FREEZE having maximized oldestXact:
         * - Start a SERIALIZABLE transaction.
         * - Start, finish, and summarize a SERIALIZABLE transaction, creating
         *   one SLRU page.
         * - Consume XIDs to reach xidStopLimit.
         * - Finish all transactions.  Due to the long-running SERIALIZABLE
         *   transaction, earlier checkpoints did not touch headPage.  The
         *   next checkpoint will change it, but that checkpoint happens after
         *   the end of the scenario.
         * - VACUUM to advance XID limits.
         * - Consume ~2M XIDs, crossing the former xidWrapLimit.
         * - Start, finish, and summarize a SERIALIZABLE transaction.
         *   SerialAdd() declines to create the targetPage, because headPage
         *   is not regarded as in the past relative to that targetPage.  The
         *   transaction instigating the summarize fails in
         *   SimpleLruReadPage().
         */
        truncateCutoffPage = serialControl->headPage;
        serialControl->headPage = -1;
    }
 
    LWLockRelease(SerialControlLock);
 
    /*
     * Truncate away pages that are no longer required.  Note that no
     * additional locking is required, because this is only called as part of
     * a checkpoint, and the validity limits have already been determined.
     */
    SimpleLruTruncate(SerialSlruCtl, truncateCutoffPage);
 
    /*
     * Write dirty SLRU pages to disk
     *
     * This is not actually necessary from a correctness point of view. We do
     * it merely as a debugging aid.
     *
     * We're doing this after the truncation to avoid writing pages right
     * before deleting the file in which they sit, which would be completely
     * pointless.
     */
    SimpleLruWriteAll(SerialSlruCtl, true);
}

References SerialControlData::headPage, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), serialControl, SerialPage, SerialPagePrecedesLogically(), SerialSlruCtl, SimpleLruTruncate(), SimpleLruWriteAll(), SerialControlData::tailXid, and TransactionIdIsValid.

Referenced by CheckPointGuts().

CheckTableForSerializableConflictIn()

void CheckTableForSerializableConflictIn

(

Relation

relation

)

Definition at line 4404 of file predicate.c.

{
    HASH_SEQ_STATUS seqstat;
    PREDICATELOCKTARGET *target;
    Oid         dbId;
    Oid         heapId;
    int         i;
 
    /*
     * Bail out quickly if there are no serializable transactions running.
     * It's safe to check this without taking locks because the caller is
     * holding an ACCESS EXCLUSIVE lock on the relation.  No new locks which
     * would matter here can be acquired while that is held.
     */
    if (!TransactionIdIsValid(PredXact->SxactGlobalXmin))
        return;
 
    if (!SerializationNeededForWrite(relation))
        return;
 
    /*
     * We're doing a write which might cause rw-conflicts now or later.
     * Memorize that fact.
     */
    MyXactDidWrite = true;
 
    Assert(relation->rd_index == NULL); /* not an index relation */
 
    dbId = relation->rd_locator.dbOid;
    heapId = relation->rd_id;
 
    LWLockAcquire(SerializablePredicateListLock, LW_EXCLUSIVE);
    for (i = 0; i < NUM_PREDICATELOCK_PARTITIONS; i++)
        LWLockAcquire(PredicateLockHashPartitionLockByIndex(i), LW_SHARED);
    LWLockAcquire(SerializableXactHashLock, LW_EXCLUSIVE);
 
    /* Scan through target list */
    hash_seq_init(&seqstat, PredicateLockTargetHash);
 
    while ((target = (PREDICATELOCKTARGET *) hash_seq_search(&seqstat)))
    {
        dlist_mutable_iter iter;
 
        /*
         * Check whether this is a target which needs attention.
         */
        if (GET_PREDICATELOCKTARGETTAG_RELATION(target->tag) != heapId)
            continue;           /* wrong relation id */
        if (GET_PREDICATELOCKTARGETTAG_DB(target->tag) != dbId)
            continue;           /* wrong database id */
 
        /*
         * Loop through locks for this target and flag conflicts.
         */
        dlist_foreach_modify(iter, &target->predicateLocks)
        {
            PREDICATELOCK *predlock =
                dlist_container(PREDICATELOCK, targetLink, iter.cur);
 
            if (predlock->tag.myXact != MySerializableXact
                && !RWConflictExists(predlock->tag.myXact, MySerializableXact))
            {
                FlagRWConflict(predlock->tag.myXact, MySerializableXact);
            }
        }
    }
 
    /* Release locks in reverse order */
    LWLockRelease(SerializableXactHashLock);
    for (i = NUM_PREDICATELOCK_PARTITIONS - 1; i >= 0; i--)
        LWLockRelease(PredicateLockHashPartitionLockByIndex(i));
    LWLockRelease(SerializablePredicateListLock);
}

References Assert, dlist_mutable_iter::cur, RelFileLocator::dbOid, dlist_container, dlist_foreach_modify, FlagRWConflict(), GET_PREDICATELOCKTARGETTAG_DB, GET_PREDICATELOCKTARGETTAG_RELATION, hash_seq_init(), hash_seq_search(), i, LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), MySerializableXact, PREDICATELOCKTAG::myXact, MyXactDidWrite, NUM_PREDICATELOCK_PARTITIONS, PredicateLockHashPartitionLockByIndex, PREDICATELOCKTARGET::predicateLocks, PredicateLockTargetHash, PredXact, RelationData::rd_id, RelationData::rd_index, RelationData::rd_locator, RWConflictExists(), SerializationNeededForWrite(), PredXactListData::SxactGlobalXmin, PREDICATELOCKTARGET::tag, PREDICATELOCK::tag, and TransactionIdIsValid.

Referenced by ExecuteTruncateGuts(), and heap_drop_with_catalog().

CheckTargetForConflictsIn()

static void CheckTargetForConflictsIn ( PREDICATELOCKTARGETTAG *  targettag )

static

Definition at line 4151 of file predicate.c.

{
    uint32      targettaghash;
    LWLock     *partitionLock;
    PREDICATELOCKTARGET *target;
    PREDICATELOCK *mypredlock = NULL;
    PREDICATELOCKTAG mypredlocktag;
    dlist_mutable_iter iter;
 
    Assert(MySerializableXact != InvalidSerializableXact);
 
    /*
     * The same hash and LW lock apply to the lock target and the lock itself.
     */
    targettaghash = PredicateLockTargetTagHashCode(targettag);
    partitionLock = PredicateLockHashPartitionLock(targettaghash);
    LWLockAcquire(partitionLock, LW_SHARED);
    target = (PREDICATELOCKTARGET *)
        hash_search_with_hash_value(PredicateLockTargetHash,
                                    targettag, targettaghash,
                                    HASH_FIND, NULL);
    if (!target)
    {
        /* Nothing has this target locked; we're done here. */
        LWLockRelease(partitionLock);
        return;
    }
 
    /*
     * Each lock for an overlapping transaction represents a conflict: a
     * rw-dependency in to this transaction.
     */
    LWLockAcquire(SerializableXactHashLock, LW_SHARED);
 
    dlist_foreach_modify(iter, &target->predicateLocks)
    {
        PREDICATELOCK *predlock =
            dlist_container(PREDICATELOCK, targetLink, iter.cur);
        SERIALIZABLEXACT *sxact = predlock->tag.myXact;
 
        if (sxact == MySerializableXact)
        {
            /*
             * If we're getting a write lock on a tuple, we don't need a
             * predicate (SIREAD) lock on the same tuple. We can safely remove
             * our SIREAD lock, but we'll defer doing so until after the loop
             * because that requires upgrading to an exclusive partition lock.
             *
             * We can't use this optimization within a subtransaction because
             * the subtransaction could roll back, and we would be left
             * without any lock at the top level.
             */
            if (!IsSubTransaction()
                && GET_PREDICATELOCKTARGETTAG_OFFSET(*targettag))
            {
                mypredlock = predlock;
                mypredlocktag = predlock->tag;
            }
        }
        else if (!SxactIsDoomed(sxact)
                 && (!SxactIsCommitted(sxact)
                     || TransactionIdPrecedes(GetTransactionSnapshot()->xmin,
                                              sxact->finishedBefore))
                 && !RWConflictExists(sxact, MySerializableXact))
        {
            LWLockRelease(SerializableXactHashLock);
            LWLockAcquire(SerializableXactHashLock, LW_EXCLUSIVE);
 
            /*
             * Re-check after getting exclusive lock because the other
             * transaction may have flagged a conflict.
             */
            if (!SxactIsDoomed(sxact)
                && (!SxactIsCommitted(sxact)
                    || TransactionIdPrecedes(GetTransactionSnapshot()->xmin,
                                             sxact->finishedBefore))
                && !RWConflictExists(sxact, MySerializableXact))
            {
                FlagRWConflict(sxact, MySerializableXact);
            }
 
            LWLockRelease(SerializableXactHashLock);
            LWLockAcquire(SerializableXactHashLock, LW_SHARED);
        }
    }
    LWLockRelease(SerializableXactHashLock);
    LWLockRelease(partitionLock);
 
    /*
     * If we found one of our own SIREAD locks to remove, remove it now.
     *
     * At this point our transaction already has a RowExclusiveLock on the
     * relation, so we are OK to drop the predicate lock on the tuple, if
     * found, without fearing that another write against the tuple will occur
     * before the MVCC information makes it to the buffer.
     */
    if (mypredlock != NULL)
    {
        uint32      predlockhashcode;
        PREDICATELOCK *rmpredlock;
 
        LWLockAcquire(SerializablePredicateListLock, LW_SHARED);
        if (IsInParallelMode())
            LWLockAcquire(&MySerializableXact->perXactPredicateListLock, LW_EXCLUSIVE);
        LWLockAcquire(partitionLock, LW_EXCLUSIVE);
        LWLockAcquire(SerializableXactHashLock, LW_EXCLUSIVE);
 
        /*
         * Remove the predicate lock from shared memory, if it wasn't removed
         * while the locks were released.  One way that could happen is from
         * autovacuum cleaning up an index.
         */
        predlockhashcode = PredicateLockHashCodeFromTargetHashCode
            (&mypredlocktag, targettaghash);
        rmpredlock = (PREDICATELOCK *)
            hash_search_with_hash_value(PredicateLockHash,
                                        &mypredlocktag,
                                        predlockhashcode,
                                        HASH_FIND, NULL);
        if (rmpredlock != NULL)
        {
            Assert(rmpredlock == mypredlock);
 
            dlist_delete(&(mypredlock->targetLink));
            dlist_delete(&(mypredlock->xactLink));
 
            rmpredlock = (PREDICATELOCK *)
                hash_search_with_hash_value(PredicateLockHash,
                                            &mypredlocktag,
                                            predlockhashcode,
                                            HASH_REMOVE, NULL);
            Assert(rmpredlock == mypredlock);
 
            RemoveTargetIfNoLongerUsed(target, targettaghash);
        }
 
        LWLockRelease(SerializableXactHashLock);
        LWLockRelease(partitionLock);
        if (IsInParallelMode())
            LWLockRelease(&MySerializableXact->perXactPredicateListLock);
        LWLockRelease(SerializablePredicateListLock);
 
        if (rmpredlock != NULL)
        {
            /*
             * Remove entry in local lock table if it exists. It's OK if it
             * doesn't exist; that means the lock was transferred to a new
             * target by a different backend.
             */
            hash_search_with_hash_value(LocalPredicateLockHash,
                                        targettag, targettaghash,
                                        HASH_REMOVE, NULL);
 
            DecrementParentLocks(targettag);
        }
    }
}

References Assert, dlist_mutable_iter::cur, DecrementParentLocks(), dlist_container, dlist_delete(), dlist_foreach_modify, SERIALIZABLEXACT::finishedBefore, FlagRWConflict(), GET_PREDICATELOCKTARGETTAG_OFFSET, GetTransactionSnapshot(), HASH_FIND, HASH_REMOVE, hash_search_with_hash_value(), InvalidSerializableXact, IsInParallelMode(), IsSubTransaction(), LocalPredicateLockHash, LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), MySerializableXact, PREDICATELOCKTAG::myXact, SERIALIZABLEXACT::perXactPredicateListLock, PredicateLockHash, PredicateLockHashCodeFromTargetHashCode, PredicateLockHashPartitionLock, PREDICATELOCKTARGET::predicateLocks, PredicateLockTargetHash, PredicateLockTargetTagHashCode, RemoveTargetIfNoLongerUsed(), RWConflictExists(), SxactIsCommitted, SxactIsDoomed, PREDICATELOCK::tag, PREDICATELOCK::targetLink, TransactionIdPrecedes(), and PREDICATELOCK::xactLink.

Referenced by CheckForSerializableConflictIn().

ClearOldPredicateLocks()

static void ClearOldPredicateLocks ( void  )

static

Definition at line 3682 of file predicate.c.

{
    dlist_mutable_iter iter;
 
    /*
     * Loop through finished transactions. They are in commit order, so we can
     * stop as soon as we find one that's still interesting.
     */
    LWLockAcquire(SerializableFinishedListLock, LW_EXCLUSIVE);
    LWLockAcquire(SerializableXactHashLock, LW_SHARED);
    dlist_foreach_modify(iter, FinishedSerializableTransactions)
    {
        SERIALIZABLEXACT *finishedSxact =
            dlist_container(SERIALIZABLEXACT, finishedLink, iter.cur);
 
        if (!TransactionIdIsValid(PredXact->SxactGlobalXmin)
            || TransactionIdPrecedesOrEquals(finishedSxact->finishedBefore,
                                             PredXact->SxactGlobalXmin))
        {
            /*
             * This transaction committed before any in-progress transaction
             * took its snapshot. It's no longer interesting.
             */
            LWLockRelease(SerializableXactHashLock);
            dlist_delete_thoroughly(&finishedSxact->finishedLink);
            ReleaseOneSerializableXact(finishedSxact, false, false);
            LWLockAcquire(SerializableXactHashLock, LW_SHARED);
        }
        else if (finishedSxact->commitSeqNo > PredXact->HavePartialClearedThrough
                 && finishedSxact->commitSeqNo <= PredXact->CanPartialClearThrough)
        {
            /*
             * Any active transactions that took their snapshot before this
             * transaction committed are read-only, so we can clear part of
             * its state.
             */
            LWLockRelease(SerializableXactHashLock);
 
            if (SxactIsReadOnly(finishedSxact))
            {
                /* A read-only transaction can be removed entirely */
                dlist_delete_thoroughly(&(finishedSxact->finishedLink));
                ReleaseOneSerializableXact(finishedSxact, false, false);
            }
            else
            {
                /*
                 * A read-write transaction can only be partially cleared. We
                 * need to keep the SERIALIZABLEXACT but can release the
                 * SIREAD locks and conflicts in.
                 */
                ReleaseOneSerializableXact(finishedSxact, true, false);
            }
 
            PredXact->HavePartialClearedThrough = finishedSxact->commitSeqNo;
            LWLockAcquire(SerializableXactHashLock, LW_SHARED);
        }
        else
        {
            /* Still interesting. */
            break;
        }
    }
    LWLockRelease(SerializableXactHashLock);
 
    /*
     * Loop through predicate locks on dummy transaction for summarized data.
     */
    LWLockAcquire(SerializablePredicateListLock, LW_SHARED);
    dlist_foreach_modify(iter, &OldCommittedSxact->predicateLocks)
    {
        PREDICATELOCK *predlock =
            dlist_container(PREDICATELOCK, xactLink, iter.cur);
        bool        canDoPartialCleanup;
 
        LWLockAcquire(SerializableXactHashLock, LW_SHARED);
        Assert(predlock->commitSeqNo != 0);
        Assert(predlock->commitSeqNo != InvalidSerCommitSeqNo);
        canDoPartialCleanup = (predlock->commitSeqNo <= PredXact->CanPartialClearThrough);
        LWLockRelease(SerializableXactHashLock);
 
        /*
         * If this lock originally belonged to an old enough transaction, we
         * can release it.
         */
        if (canDoPartialCleanup)
        {
            PREDICATELOCKTAG tag;
            PREDICATELOCKTARGET *target;
            PREDICATELOCKTARGETTAG targettag;
            uint32      targettaghash;
            LWLock     *partitionLock;
 
            tag = predlock->tag;
            target = tag.myTarget;
            targettag = target->tag;
            targettaghash = PredicateLockTargetTagHashCode(&targettag);
            partitionLock = PredicateLockHashPartitionLock(targettaghash);
 
            LWLockAcquire(partitionLock, LW_EXCLUSIVE);
 
            dlist_delete(&(predlock->targetLink));
            dlist_delete(&(predlock->xactLink));
 
            hash_search_with_hash_value(PredicateLockHash, &tag,
                                        PredicateLockHashCodeFromTargetHashCode(&tag,
                                                                                targettaghash),
                                        HASH_REMOVE, NULL);
            RemoveTargetIfNoLongerUsed(target, targettaghash);
 
            LWLockRelease(partitionLock);
        }
    }
 
    LWLockRelease(SerializablePredicateListLock);
    LWLockRelease(SerializableFinishedListLock);
}

References Assert, PredXactListData::CanPartialClearThrough, SERIALIZABLEXACT::commitSeqNo, PREDICATELOCK::commitSeqNo, dlist_mutable_iter::cur, dlist_container, dlist_delete(), dlist_delete_thoroughly(), dlist_foreach_modify, SERIALIZABLEXACT::finishedBefore, SERIALIZABLEXACT::finishedLink, FinishedSerializableTransactions, HASH_REMOVE, hash_search_with_hash_value(), PredXactListData::HavePartialClearedThrough, InvalidSerCommitSeqNo, LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), PREDICATELOCKTAG::myTarget, OldCommittedSxact, PredicateLockHash, PredicateLockHashCodeFromTargetHashCode, PredicateLockHashPartitionLock, SERIALIZABLEXACT::predicateLocks, PredicateLockTargetTagHashCode, PredXact, ReleaseOneSerializableXact(), RemoveTargetIfNoLongerUsed(), PredXactListData::SxactGlobalXmin, SxactIsReadOnly, PREDICATELOCKTARGET::tag, PREDICATELOCK::tag, PREDICATELOCK::targetLink, TransactionIdIsValid, TransactionIdPrecedesOrEquals(), and PREDICATELOCK::xactLink.

Referenced by ReleasePredicateLocks().

CoarserLockCovers()

static bool CoarserLockCovers ( const PREDICATELOCKTARGETTAG *  newtargettag )

static

Definition at line 2096 of file predicate.c.

{
    PREDICATELOCKTARGETTAG targettag,
                parenttag;
 
    targettag = *newtargettag;
 
    /* check parents iteratively until no more */
    while (GetParentPredicateLockTag(&targettag, &parenttag))
    {
        targettag = parenttag;
        if (PredicateLockExists(&targettag))
            return true;
    }
 
    /* no more parents to check; lock is not covered */
    return false;
}

References GetParentPredicateLockTag(), and PredicateLockExists().

Referenced by PredicateLockAcquire().

CreateLocalPredicateLockHash()

static void CreateLocalPredicateLockHash ( void  )

static

Definition at line 1925 of file predicate.c.

{
    HASHCTL     hash_ctl;
 
    /* Initialize the backend-local hash table of parent locks */
    Assert(LocalPredicateLockHash == NULL);
    hash_ctl.keysize = sizeof(PREDICATELOCKTARGETTAG);
    hash_ctl.entrysize = sizeof(LOCALPREDICATELOCK);
    LocalPredicateLockHash = hash_create("Local predicate lock",
                                         max_predicate_locks_per_xact,
                                         &hash_ctl,
                                         HASH_ELEM | HASH_BLOBS);
}

References Assert, HASHCTL::entrysize, HASH_BLOBS, hash_create(), HASH_ELEM, HASHCTL::keysize, LocalPredicateLockHash, and max_predicate_locks_per_xact.

Referenced by AttachSerializableXact(), and GetSerializableTransactionSnapshotInt().

CreatePredicateLock()

static void CreatePredicateLock ( const PREDICATELOCKTARGETTAG *  targettag, uint32  targettaghash, SERIALIZABLEXACT *  sxact  )

static

Definition at line 2438 of file predicate.c.

{
    PREDICATELOCKTARGET *target;
    PREDICATELOCKTAG locktag;
    PREDICATELOCK *lock;
    LWLock     *partitionLock;
    bool        found;
 
    partitionLock = PredicateLockHashPartitionLock(targettaghash);
 
    LWLockAcquire(SerializablePredicateListLock, LW_SHARED);
    if (IsInParallelMode())
        LWLockAcquire(&sxact->perXactPredicateListLock, LW_EXCLUSIVE);
    LWLockAcquire(partitionLock, LW_EXCLUSIVE);
 
    /* Make sure that the target is represented. */
    target = (PREDICATELOCKTARGET *)
        hash_search_with_hash_value(PredicateLockTargetHash,
                                    targettag, targettaghash,
                                    HASH_ENTER_NULL, &found);
    if (!target)
        ereport(ERROR,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of shared memory"),
                 errhint("You might need to increase \"%s\".", "max_pred_locks_per_transaction")));
    if (!found)
        dlist_init(&target->predicateLocks);
 
    /* We've got the sxact and target, make sure they're joined. */
    locktag.myTarget = target;
    locktag.myXact = sxact;
    lock = (PREDICATELOCK *)
        hash_search_with_hash_value(PredicateLockHash, &locktag,
                                    PredicateLockHashCodeFromTargetHashCode(&locktag, targettaghash),
                                    HASH_ENTER_NULL, &found);
    if (!lock)
        ereport(ERROR,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of shared memory"),
                 errhint("You might need to increase \"%s\".", "max_pred_locks_per_transaction")));
 
    if (!found)
    {
        dlist_push_tail(&target->predicateLocks, &lock->targetLink);
        dlist_push_tail(&sxact->predicateLocks, &lock->xactLink);
        lock->commitSeqNo = InvalidSerCommitSeqNo;
    }
 
    LWLockRelease(partitionLock);
    if (IsInParallelMode())
        LWLockRelease(&sxact->perXactPredicateListLock);
    LWLockRelease(SerializablePredicateListLock);
}

References PREDICATELOCK::commitSeqNo, dlist_init(), dlist_push_tail(), ereport, errcode(), errhint(), errmsg(), ERROR, HASH_ENTER_NULL, hash_search_with_hash_value(), InvalidSerCommitSeqNo, IsInParallelMode(), LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), PREDICATELOCKTAG::myTarget, PREDICATELOCKTAG::myXact, SERIALIZABLEXACT::perXactPredicateListLock, PredicateLockHash, PredicateLockHashCodeFromTargetHashCode, PredicateLockHashPartitionLock, SERIALIZABLEXACT::predicateLocks, PREDICATELOCKTARGET::predicateLocks, PredicateLockTargetHash, PREDICATELOCK::targetLink, and PREDICATELOCK::xactLink.

Referenced by predicatelock_twophase_recover(), and PredicateLockAcquire().

CreatePredXact()

static SERIALIZABLEXACT * CreatePredXact ( void  )

static

Definition at line 582 of file predicate.c.

{
    SERIALIZABLEXACT *sxact;
 
    if (dlist_is_empty(&PredXact->availableList))
        return NULL;
 
    sxact = dlist_container(SERIALIZABLEXACT, xactLink,
                            dlist_pop_head_node(&PredXact->availableList));
    dlist_push_tail(&PredXact->activeList, &sxact->xactLink);
    return sxact;
}

References PredXactListData::activeList, PredXactListData::availableList, dlist_container, dlist_is_empty(), dlist_pop_head_node(), dlist_push_tail(), PredXact, and SERIALIZABLEXACT::xactLink.

Referenced by GetSerializableTransactionSnapshotInt(), predicatelock_twophase_recover(), and PredicateLockShmemInit().

DecrementParentLocks()

static void DecrementParentLocks ( const PREDICATELOCKTARGETTAG *  targettag )

static

Definition at line 2376 of file predicate.c.

{
    PREDICATELOCKTARGETTAG parenttag,
                nexttag;
 
    parenttag = *targettag;
 
    while (GetParentPredicateLockTag(&parenttag, &nexttag))
    {
        uint32      targettaghash;
        LOCALPREDICATELOCK *parentlock,
                   *rmlock PG_USED_FOR_ASSERTS_ONLY;
 
        parenttag = nexttag;
        targettaghash = PredicateLockTargetTagHashCode(&parenttag);
        parentlock = (LOCALPREDICATELOCK *)
            hash_search_with_hash_value(LocalPredicateLockHash,
                                        &parenttag, targettaghash,
                                        HASH_FIND, NULL);
 
        /*
         * There's a small chance the parent lock doesn't exist in the lock
         * table. This can happen if we prematurely removed it because an
         * index split caused the child refcount to be off.
         */
        if (parentlock == NULL)
            continue;
 
        parentlock->childLocks--;
 
        /*
         * Under similar circumstances the parent lock's refcount might be
         * zero. This only happens if we're holding that lock (otherwise we
         * would have removed the entry).
         */
        if (parentlock->childLocks < 0)
        {
            Assert(parentlock->held);
            parentlock->childLocks = 0;
        }
 
        if ((parentlock->childLocks == 0) && (!parentlock->held))
        {
            rmlock = (LOCALPREDICATELOCK *)
                hash_search_with_hash_value(LocalPredicateLockHash,
                                            &parenttag, targettaghash,
                                            HASH_REMOVE, NULL);
            Assert(rmlock == parentlock);
        }
    }
}

References Assert, LOCALPREDICATELOCK::childLocks, GetParentPredicateLockTag(), HASH_FIND, HASH_REMOVE, hash_search_with_hash_value(), LOCALPREDICATELOCK::held, LocalPredicateLockHash, PG_USED_FOR_ASSERTS_ONLY, and PredicateLockTargetTagHashCode.

Referenced by CheckTargetForConflictsIn(), and DeleteChildTargetLocks().

DeleteChildTargetLocks()

static void DeleteChildTargetLocks ( const PREDICATELOCKTARGETTAG *  newtargettag )

static

Definition at line 2199 of file predicate.c.

{
    SERIALIZABLEXACT *sxact;
    PREDICATELOCK *predlock;
    dlist_mutable_iter iter;
 
    LWLockAcquire(SerializablePredicateListLock, LW_SHARED);
    sxact = MySerializableXact;
    if (IsInParallelMode())
        LWLockAcquire(&sxact->perXactPredicateListLock, LW_EXCLUSIVE);
 
    dlist_foreach_modify(iter, &sxact->predicateLocks)
    {
        PREDICATELOCKTAG oldlocktag;
        PREDICATELOCKTARGET *oldtarget;
        PREDICATELOCKTARGETTAG oldtargettag;
 
        predlock = dlist_container(PREDICATELOCK, xactLink, iter.cur);
 
        oldlocktag = predlock->tag;
        Assert(oldlocktag.myXact == sxact);
        oldtarget = oldlocktag.myTarget;
        oldtargettag = oldtarget->tag;
 
        if (TargetTagIsCoveredBy(oldtargettag, *newtargettag))
        {
            uint32      oldtargettaghash;
            LWLock     *partitionLock;
            PREDICATELOCK *rmpredlock PG_USED_FOR_ASSERTS_ONLY;
 
            oldtargettaghash = PredicateLockTargetTagHashCode(&oldtargettag);
            partitionLock = PredicateLockHashPartitionLock(oldtargettaghash);
 
            LWLockAcquire(partitionLock, LW_EXCLUSIVE);
 
            dlist_delete(&predlock->xactLink);
            dlist_delete(&predlock->targetLink);
            rmpredlock = hash_search_with_hash_value
                (PredicateLockHash,
                 &oldlocktag,
                 PredicateLockHashCodeFromTargetHashCode(&oldlocktag,
                                                         oldtargettaghash),
                 HASH_REMOVE, NULL);
            Assert(rmpredlock == predlock);
 
            RemoveTargetIfNoLongerUsed(oldtarget, oldtargettaghash);
 
            LWLockRelease(partitionLock);
 
            DecrementParentLocks(&oldtargettag);
        }
    }
    if (IsInParallelMode())
        LWLockRelease(&sxact->perXactPredicateListLock);
    LWLockRelease(SerializablePredicateListLock);
}

References Assert, dlist_mutable_iter::cur, DecrementParentLocks(), dlist_container, dlist_delete(), dlist_foreach_modify, HASH_REMOVE, hash_search_with_hash_value(), IsInParallelMode(), LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), MySerializableXact, PREDICATELOCKTAG::myTarget, PREDICATELOCKTAG::myXact, SERIALIZABLEXACT::perXactPredicateListLock, PG_USED_FOR_ASSERTS_ONLY, PredicateLockHash, PredicateLockHashCodeFromTargetHashCode, PredicateLockHashPartitionLock, SERIALIZABLEXACT::predicateLocks, PredicateLockTargetTagHashCode, RemoveTargetIfNoLongerUsed(), PREDICATELOCKTARGET::tag, PREDICATELOCK::tag, PREDICATELOCK::targetLink, TargetTagIsCoveredBy, and PREDICATELOCK::xactLink.

Referenced by PredicateLockAcquire().

DeleteLockTarget()

static void DeleteLockTarget ( PREDICATELOCKTARGET *  target, uint32  targettaghash  )

static

Definition at line 2654 of file predicate.c.

{
    dlist_mutable_iter iter;
 
    Assert(LWLockHeldByMeInMode(SerializablePredicateListLock,
                                LW_EXCLUSIVE));
    Assert(LWLockHeldByMe(PredicateLockHashPartitionLock(targettaghash)));
 
    LWLockAcquire(SerializableXactHashLock, LW_EXCLUSIVE);
 
    dlist_foreach_modify(iter, &target->predicateLocks)
    {
        PREDICATELOCK *predlock =
            dlist_container(PREDICATELOCK, targetLink, iter.cur);
        bool        found;
 
        dlist_delete(&(predlock->xactLink));
        dlist_delete(&(predlock->targetLink));
 
        hash_search_with_hash_value
            (PredicateLockHash,
             &predlock->tag,
             PredicateLockHashCodeFromTargetHashCode(&predlock->tag,
                                                     targettaghash),
             HASH_REMOVE, &found);
        Assert(found);
    }
    LWLockRelease(SerializableXactHashLock);
 
    /* Remove the target itself, if possible. */
    RemoveTargetIfNoLongerUsed(target, targettaghash);
}

References Assert, dlist_mutable_iter::cur, dlist_container, dlist_delete(), dlist_foreach_modify, HASH_REMOVE, hash_search_with_hash_value(), LW_EXCLUSIVE, LWLockAcquire(), LWLockHeldByMe(), LWLockHeldByMeInMode(), LWLockRelease(), PredicateLockHash, PredicateLockHashCodeFromTargetHashCode, PredicateLockHashPartitionLock, PREDICATELOCKTARGET::predicateLocks, RemoveTargetIfNoLongerUsed(), PREDICATELOCK::tag, PREDICATELOCK::targetLink, and PREDICATELOCK::xactLink.

Referenced by TransferPredicateLocksToNewTarget().

DropAllPredicateLocksFromTable()

static void DropAllPredicateLocksFromTable ( Relation  relation, bool  transfer  )

static

Definition at line 2922 of file predicate.c.

{
    HASH_SEQ_STATUS seqstat;
    PREDICATELOCKTARGET *oldtarget;
    PREDICATELOCKTARGET *heaptarget;
    Oid         dbId;
    Oid         relId;
    Oid         heapId;
    int         i;
    bool        isIndex;
    bool        found;
    uint32      heaptargettaghash;
 
    /*
     * Bail out quickly if there are no serializable transactions running.
     * It's safe to check this without taking locks because the caller is
     * holding an ACCESS EXCLUSIVE lock on the relation.  No new locks which
     * would matter here can be acquired while that is held.
     */
    if (!TransactionIdIsValid(PredXact->SxactGlobalXmin))
        return;
 
    if (!PredicateLockingNeededForRelation(relation))
        return;
 
    dbId = relation->rd_locator.dbOid;
    relId = relation->rd_id;
    if (relation->rd_index == NULL)
    {
        isIndex = false;
        heapId = relId;
    }
    else
    {
        isIndex = true;
        heapId = relation->rd_index->indrelid;
    }
    Assert(heapId != InvalidOid);
    Assert(transfer || !isIndex);   /* index OID only makes sense with
                                     * transfer */
 
    /* Retrieve first time needed, then keep. */
    heaptargettaghash = 0;
    heaptarget = NULL;
 
    /* Acquire locks on all lock partitions */
    LWLockAcquire(SerializablePredicateListLock, LW_EXCLUSIVE);
    for (i = 0; i < NUM_PREDICATELOCK_PARTITIONS; i++)
        LWLockAcquire(PredicateLockHashPartitionLockByIndex(i), LW_EXCLUSIVE);
    LWLockAcquire(SerializableXactHashLock, LW_EXCLUSIVE);
 
    /*
     * Remove the dummy entry to give us scratch space, so we know we'll be
     * able to create the new lock target.
     */
    if (transfer)
        RemoveScratchTarget(true);
 
    /* Scan through target map */
    hash_seq_init(&seqstat, PredicateLockTargetHash);
 
    while ((oldtarget = (PREDICATELOCKTARGET *) hash_seq_search(&seqstat)))
    {
        dlist_mutable_iter iter;
 
        /*
         * Check whether this is a target which needs attention.
         */
        if (GET_PREDICATELOCKTARGETTAG_RELATION(oldtarget->tag) != relId)
            continue;           /* wrong relation id */
        if (GET_PREDICATELOCKTARGETTAG_DB(oldtarget->tag) != dbId)
            continue;           /* wrong database id */
        if (transfer && !isIndex
            && GET_PREDICATELOCKTARGETTAG_TYPE(oldtarget->tag) == PREDLOCKTAG_RELATION)
            continue;           /* already the right lock */
 
        /*
         * If we made it here, we have work to do.  We make sure the heap
         * relation lock exists, then we walk the list of predicate locks for
         * the old target we found, moving all locks to the heap relation lock
         * -- unless they already hold that.
         */
 
        /*
         * First make sure we have the heap relation target.  We only need to
         * do this once.
         */
        if (transfer && heaptarget == NULL)
        {
            PREDICATELOCKTARGETTAG heaptargettag;
 
            SET_PREDICATELOCKTARGETTAG_RELATION(heaptargettag, dbId, heapId);
            heaptargettaghash = PredicateLockTargetTagHashCode(&heaptargettag);
            heaptarget = hash_search_with_hash_value(PredicateLockTargetHash,
                                                     &heaptargettag,
                                                     heaptargettaghash,
                                                     HASH_ENTER, &found);
            if (!found)
                dlist_init(&heaptarget->predicateLocks);
        }
 
        /*
         * Loop through all the locks on the old target, replacing them with
         * locks on the new target.
         */
        dlist_foreach_modify(iter, &oldtarget->predicateLocks)
        {
            PREDICATELOCK *oldpredlock =
                dlist_container(PREDICATELOCK, targetLink, iter.cur);
            PREDICATELOCK *newpredlock;
            SerCommitSeqNo oldCommitSeqNo;
            SERIALIZABLEXACT *oldXact;
 
            /*
             * Remove the old lock first. This avoids the chance of running
             * out of lock structure entries for the hash table.
             */
            oldCommitSeqNo = oldpredlock->commitSeqNo;
            oldXact = oldpredlock->tag.myXact;
 
            dlist_delete(&(oldpredlock->xactLink));
 
            /*
             * No need for retail delete from oldtarget list, we're removing
             * the whole target anyway.
             */
            hash_search(PredicateLockHash,
                        &oldpredlock->tag,
                        HASH_REMOVE, &found);
            Assert(found);
 
            if (transfer)
            {
                PREDICATELOCKTAG newpredlocktag;
 
                newpredlocktag.myTarget = heaptarget;
                newpredlocktag.myXact = oldXact;
                newpredlock = (PREDICATELOCK *)
                    hash_search_with_hash_value(PredicateLockHash,
                                                &newpredlocktag,
                                                PredicateLockHashCodeFromTargetHashCode(&newpredlocktag,
                                                                                        heaptargettaghash),
                                                HASH_ENTER,
                                                &found);
                if (!found)
                {
                    dlist_push_tail(&(heaptarget->predicateLocks),
                                    &(newpredlock->targetLink));
                    dlist_push_tail(&(newpredlocktag.myXact->predicateLocks),
                                    &(newpredlock->xactLink));
                    newpredlock->commitSeqNo = oldCommitSeqNo;
                }
                else
                {
                    if (newpredlock->commitSeqNo < oldCommitSeqNo)
                        newpredlock->commitSeqNo = oldCommitSeqNo;
                }
 
                Assert(newpredlock->commitSeqNo != 0);
                Assert((newpredlock->commitSeqNo == InvalidSerCommitSeqNo)
                       || (newpredlock->tag.myXact == OldCommittedSxact));
            }
        }
 
        hash_search(PredicateLockTargetHash, &oldtarget->tag, HASH_REMOVE,
                    &found);
        Assert(found);
    }
 
    /* Put the scratch entry back */
    if (transfer)
        RestoreScratchTarget(true);
 
    /* Release locks in reverse order */
    LWLockRelease(SerializableXactHashLock);
    for (i = NUM_PREDICATELOCK_PARTITIONS - 1; i >= 0; i--)
        LWLockRelease(PredicateLockHashPartitionLockByIndex(i));
    LWLockRelease(SerializablePredicateListLock);
}

References Assert, PREDICATELOCK::commitSeqNo, dlist_mutable_iter::cur, RelFileLocator::dbOid, dlist_container, dlist_delete(), dlist_foreach_modify, dlist_init(), dlist_push_tail(), GET_PREDICATELOCKTARGETTAG_DB, GET_PREDICATELOCKTARGETTAG_RELATION, GET_PREDICATELOCKTARGETTAG_TYPE, HASH_ENTER, HASH_REMOVE, hash_search(), hash_search_with_hash_value(), hash_seq_init(), hash_seq_search(), i, InvalidOid, InvalidSerCommitSeqNo, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), PREDICATELOCKTAG::myTarget, PREDICATELOCKTAG::myXact, NUM_PREDICATELOCK_PARTITIONS, OldCommittedSxact, PredicateLockHash, PredicateLockHashCodeFromTargetHashCode, PredicateLockHashPartitionLockByIndex, PredicateLockingNeededForRelation(), SERIALIZABLEXACT::predicateLocks, PREDICATELOCKTARGET::predicateLocks, PredicateLockTargetHash, PredicateLockTargetTagHashCode, PREDLOCKTAG_RELATION, PredXact, RelationData::rd_id, RelationData::rd_index, RelationData::rd_locator, RemoveScratchTarget(), RestoreScratchTarget(), SET_PREDICATELOCKTARGETTAG_RELATION, PredXactListData::SxactGlobalXmin, PREDICATELOCKTARGET::tag, PREDICATELOCK::tag, PREDICATELOCK::targetLink, TransactionIdIsValid, and PREDICATELOCK::xactLink.

Referenced by TransferPredicateLocksToHeapRelation().

FlagRWConflict()

static void FlagRWConflict ( SERIALIZABLEXACT *  reader, SERIALIZABLEXACT *  writer  )

static

Definition at line 4486 of file predicate.c.

{
    Assert(reader != writer);
 
    /* First, see if this conflict causes failure. */
    OnConflict_CheckForSerializationFailure(reader, writer);
 
    /* Actually do the conflict flagging. */
    if (reader == OldCommittedSxact)
        writer->flags |= SXACT_FLAG_SUMMARY_CONFLICT_IN;
    else if (writer == OldCommittedSxact)
        reader->flags |= SXACT_FLAG_SUMMARY_CONFLICT_OUT;
    else
        SetRWConflict(reader, writer);
}

References Assert, SERIALIZABLEXACT::flags, OldCommittedSxact, OnConflict_CheckForSerializationFailure(), SetRWConflict(), SXACT_FLAG_SUMMARY_CONFLICT_IN, and SXACT_FLAG_SUMMARY_CONFLICT_OUT.

Referenced by CheckForSerializableConflictOut(), CheckTableForSerializableConflictIn(), and CheckTargetForConflictsIn().

FlagSxactUnsafe()

static void FlagSxactUnsafe ( SERIALIZABLEXACT *  sxact )

static

Definition at line 699 of file predicate.c.

{
    dlist_mutable_iter iter;
 
    Assert(SxactIsReadOnly(sxact));
    Assert(!SxactIsROSafe(sxact));
 
    sxact->flags |= SXACT_FLAG_RO_UNSAFE;
 
    /*
     * We know this isn't a safe snapshot, so we can stop looking for other
     * potential conflicts.
     */
    dlist_foreach_modify(iter, &sxact->possibleUnsafeConflicts)
    {
        RWConflict  conflict =
            dlist_container(RWConflictData, inLink, iter.cur);
 
        Assert(!SxactIsReadOnly(conflict->sxactOut));
        Assert(sxact == conflict->sxactIn);
 
        ReleaseRWConflict(conflict);
    }
}

References Assert, dlist_mutable_iter::cur, dlist_container, dlist_foreach_modify, SERIALIZABLEXACT::flags, SERIALIZABLEXACT::possibleUnsafeConflicts, ReleaseRWConflict(), SXACT_FLAG_RO_UNSAFE, RWConflictData::sxactIn, SxactIsReadOnly, SxactIsROSafe, and RWConflictData::sxactOut.

Referenced by ReleasePredicateLocks().

GetParentPredicateLockTag()

static bool GetParentPredicateLockTag ( const PREDICATELOCKTARGETTAG *  tag, PREDICATELOCKTARGETTAG *  parent  )

static

Definition at line 2057 of file predicate.c.

{
    switch (GET_PREDICATELOCKTARGETTAG_TYPE(*tag))
    {
        case PREDLOCKTAG_RELATION:
            /* relation locks have no parent lock */
            return false;
 
        case PREDLOCKTAG_PAGE:
            /* parent lock is relation lock */
            SET_PREDICATELOCKTARGETTAG_RELATION(*parent,
                                                GET_PREDICATELOCKTARGETTAG_DB(*tag),
                                                GET_PREDICATELOCKTARGETTAG_RELATION(*tag));
 
            return true;
 
        case PREDLOCKTAG_TUPLE:
            /* parent lock is page lock */
            SET_PREDICATELOCKTARGETTAG_PAGE(*parent,
                                            GET_PREDICATELOCKTARGETTAG_DB(*tag),
                                            GET_PREDICATELOCKTARGETTAG_RELATION(*tag),
                                            GET_PREDICATELOCKTARGETTAG_PAGE(*tag));
            return true;
    }
 
    /* not reachable */
    Assert(false);
    return false;
}

References Assert, GET_PREDICATELOCKTARGETTAG_DB, GET_PREDICATELOCKTARGETTAG_PAGE, GET_PREDICATELOCKTARGETTAG_RELATION, GET_PREDICATELOCKTARGETTAG_TYPE, PREDLOCKTAG_PAGE, PREDLOCKTAG_RELATION, PREDLOCKTAG_TUPLE, SET_PREDICATELOCKTARGETTAG_PAGE, and SET_PREDICATELOCKTARGETTAG_RELATION.

Referenced by CheckAndPromotePredicateLockRequest(), CoarserLockCovers(), DecrementParentLocks(), and PredicateLockPageSplit().

GetPredicateLockStatusData()

PredicateLockData* GetPredicateLockStatusData

(

void

)

Definition at line 1430 of file predicate.c.

{
    PredicateLockData *data;
    int         i;
    int         els,
                el;
    HASH_SEQ_STATUS seqstat;
    PREDICATELOCK *predlock;
 
    data = (PredicateLockData *) palloc(sizeof(PredicateLockData));
 
    /*
     * To ensure consistency, take simultaneous locks on all partition locks
     * in ascending order, then SerializableXactHashLock.
     */
    for (i = 0; i < NUM_PREDICATELOCK_PARTITIONS; i++)
        LWLockAcquire(PredicateLockHashPartitionLockByIndex(i), LW_SHARED);
    LWLockAcquire(SerializableXactHashLock, LW_SHARED);
 
    /* Get number of locks and allocate appropriately-sized arrays. */
    els = hash_get_num_entries(PredicateLockHash);
    data->nelements = els;
    data->locktags = (PREDICATELOCKTARGETTAG *)
        palloc(sizeof(PREDICATELOCKTARGETTAG) * els);
    data->xacts = (SERIALIZABLEXACT *)
        palloc(sizeof(SERIALIZABLEXACT) * els);
 
 
    /* Scan through PredicateLockHash and copy contents */
    hash_seq_init(&seqstat, PredicateLockHash);
 
    el = 0;
 
    while ((predlock = (PREDICATELOCK *) hash_seq_search(&seqstat)))
    {
        data->locktags[el] = predlock->tag.myTarget->tag;
        data->xacts[el] = *predlock->tag.myXact;
        el++;
    }
 
    Assert(el == els);
 
    /* Release locks in reverse order */
    LWLockRelease(SerializableXactHashLock);
    for (i = NUM_PREDICATELOCK_PARTITIONS - 1; i >= 0; i--)
        LWLockRelease(PredicateLockHashPartitionLockByIndex(i));
 
    return data;
}

References Assert, data, hash_get_num_entries(), hash_seq_init(), hash_seq_search(), i, LW_SHARED, LWLockAcquire(), LWLockRelease(), PREDICATELOCKTAG::myTarget, PREDICATELOCKTAG::myXact, NUM_PREDICATELOCK_PARTITIONS, palloc(), PredicateLockHash, PredicateLockHashPartitionLockByIndex, PREDICATELOCKTARGET::tag, and PREDICATELOCK::tag.

Referenced by pg_lock_status().

GetSafeSnapshot()

static Snapshot GetSafeSnapshot ( Snapshot  origSnapshot )

static

Definition at line 1543 of file predicate.c.

{
    Snapshot    snapshot;
 
    Assert(XactReadOnly && XactDeferrable);
 
    while (true)
    {
        /*
         * GetSerializableTransactionSnapshotInt is going to call
         * GetSnapshotData, so we need to provide it the static snapshot area
         * our caller passed to us.  The pointer returned is actually the same
         * one passed to it, but we avoid assuming that here.
         */
        snapshot = GetSerializableTransactionSnapshotInt(origSnapshot,
                                                         NULL, InvalidPid);
 
        if (MySerializableXact == InvalidSerializableXact)
            return snapshot;    /* no concurrent r/w xacts; it's safe */
 
        LWLockAcquire(SerializableXactHashLock, LW_EXCLUSIVE);
 
        /*
         * Wait for concurrent transactions to finish. Stop early if one of
         * them marked us as conflicted.
         */
        MySerializableXact->flags |= SXACT_FLAG_DEFERRABLE_WAITING;
        while (!(dlist_is_empty(&MySerializableXact->possibleUnsafeConflicts) ||
                 SxactIsROUnsafe(MySerializableXact)))
        {
            LWLockRelease(SerializableXactHashLock);
            ProcWaitForSignal(WAIT_EVENT_SAFE_SNAPSHOT);
            LWLockAcquire(SerializableXactHashLock, LW_EXCLUSIVE);
        }
        MySerializableXact->flags &= ~SXACT_FLAG_DEFERRABLE_WAITING;
 
        if (!SxactIsROUnsafe(MySerializableXact))
        {
            LWLockRelease(SerializableXactHashLock);
            break;              /* success */
        }
 
        LWLockRelease(SerializableXactHashLock);
 
        /* else, need to retry... */
        ereport(DEBUG2,
                (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
                 errmsg_internal("deferrable snapshot was unsafe; trying a new one")));
        ReleasePredicateLocks(false, false);
    }
 
    /*
     * Now we have a safe snapshot, so we don't need to do any further checks.
     */
    Assert(SxactIsROSafe(MySerializableXact));
    ReleasePredicateLocks(false, true);
 
    return snapshot;
}

References Assert, DEBUG2, dlist_is_empty(), ereport, errcode(), ERRCODE_T_R_SERIALIZATION_FAILURE, errmsg_internal(), SERIALIZABLEXACT::flags, GetSerializableTransactionSnapshotInt(), InvalidPid, InvalidSerializableXact, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MySerializableXact, SERIALIZABLEXACT::possibleUnsafeConflicts, ProcWaitForSignal(), ReleasePredicateLocks(), SXACT_FLAG_DEFERRABLE_WAITING, SxactIsROSafe, SxactIsROUnsafe, XactDeferrable, and XactReadOnly.

Referenced by GetSerializableTransactionSnapshot().

GetSafeSnapshotBlockingPids()

int GetSafeSnapshotBlockingPids	(	int	blocked_pid,
		int *	output,
		int	output_size
	)

Definition at line 1613 of file predicate.c.

{
    int         num_written = 0;
    dlist_iter  iter;
    SERIALIZABLEXACT *blocking_sxact = NULL;
 
    LWLockAcquire(SerializableXactHashLock, LW_SHARED);
 
    /* Find blocked_pid's SERIALIZABLEXACT by linear search. */
    dlist_foreach(iter, &PredXact->activeList)
    {
        SERIALIZABLEXACT *sxact =
            dlist_container(SERIALIZABLEXACT, xactLink, iter.cur);
 
        if (sxact->pid == blocked_pid)
        {
            blocking_sxact = sxact;
            break;
        }
    }
 
    /* Did we find it, and is it currently waiting in GetSafeSnapshot? */
    if (blocking_sxact != NULL && SxactIsDeferrableWaiting(blocking_sxact))
    {
        /* Traverse the list of possible unsafe conflicts collecting PIDs. */
        dlist_foreach(iter, &blocking_sxact->possibleUnsafeConflicts)
        {
            RWConflict  possibleUnsafeConflict =
                dlist_container(RWConflictData, inLink, iter.cur);
 
            output[num_written++] = possibleUnsafeConflict->sxactOut->pid;
 
            if (num_written >= output_size)
                break;
        }
    }
 
    LWLockRelease(SerializableXactHashLock);
 
    return num_written;
}

References PredXactListData::activeList, dlist_iter::cur, dlist_container, dlist_foreach, LW_SHARED, LWLockAcquire(), LWLockRelease(), output, SERIALIZABLEXACT::pid, SERIALIZABLEXACT::possibleUnsafeConflicts, PredXact, SxactIsDeferrableWaiting, and RWConflictData::sxactOut.

Referenced by pg_isolation_test_session_is_blocked(), and pg_safe_snapshot_blocking_pids().

GetSerializableTransactionSnapshot()

Snapshot GetSerializableTransactionSnapshot

(

Snapshot

snapshot

)

Definition at line 1667 of file predicate.c.

{
    Assert(IsolationIsSerializable());
 
    /*
     * Can't use serializable mode while recovery is still active, as it is,
     * for example, on a hot standby.  We could get here despite the check in
     * check_transaction_isolation() if default_transaction_isolation is set
     * to serializable, so phrase the hint accordingly.
     */
    if (RecoveryInProgress())
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot use serializable mode in a hot standby"),
                 errdetail("\"default_transaction_isolation\" is set to \"serializable\"."),
                 errhint("You can use \"SET default_transaction_isolation = 'repeatable read'\" to change the default.")));
 
    /*
     * A special optimization is available for SERIALIZABLE READ ONLY
     * DEFERRABLE transactions -- we can wait for a suitable snapshot and
     * thereby avoid all SSI overhead once it's running.
     */
    if (XactReadOnly && XactDeferrable)
        return GetSafeSnapshot(snapshot);
 
    return GetSerializableTransactionSnapshotInt(snapshot,
                                                 NULL, InvalidPid);
}

References Assert, ereport, errcode(), errdetail(), errhint(), errmsg(), ERROR, GetSafeSnapshot(), GetSerializableTransactionSnapshotInt(), InvalidPid, IsolationIsSerializable, RecoveryInProgress(), XactDeferrable, and XactReadOnly.

Referenced by GetTransactionSnapshot().

GetSerializableTransactionSnapshotInt()

static Snapshot GetSerializableTransactionSnapshotInt ( Snapshot  snapshot, VirtualTransactionId *  sourcevxid, int  sourcepid  )

static

Definition at line 1749 of file predicate.c.

{
    PGPROC     *proc;
    VirtualTransactionId vxid;
    SERIALIZABLEXACT *sxact,
               *othersxact;
 
    /* We only do this for serializable transactions.  Once. */
    Assert(MySerializableXact == InvalidSerializableXact);
 
    Assert(!RecoveryInProgress());
 
    /*
     * Since all parts of a serializable transaction must use the same
     * snapshot, it is too late to establish one after a parallel operation
     * has begun.
     */
    if (IsInParallelMode())
        elog(ERROR, "cannot establish serializable snapshot during a parallel operation");
 
    proc = MyProc;
    Assert(proc != NULL);
    GET_VXID_FROM_PGPROC(vxid, *proc);
 
    /*
     * First we get the sxact structure, which may involve looping and access
     * to the "finished" list to free a structure for use.
     *
     * We must hold SerializableXactHashLock when taking/checking the snapshot
     * to avoid race conditions, for much the same reasons that
     * GetSnapshotData takes the ProcArrayLock.  Since we might have to
     * release SerializableXactHashLock to call SummarizeOldestCommittedSxact,
     * this means we have to create the sxact first, which is a bit annoying
     * (in particular, an elog(ERROR) in procarray.c would cause us to leak
     * the sxact).  Consider refactoring to avoid this.
     */
#ifdef TEST_SUMMARIZE_SERIAL
    SummarizeOldestCommittedSxact();
#endif
    LWLockAcquire(SerializableXactHashLock, LW_EXCLUSIVE);
    do
    {
        sxact = CreatePredXact();
        /* If null, push out committed sxact to SLRU summary & retry. */
        if (!sxact)
        {
            LWLockRelease(SerializableXactHashLock);
            SummarizeOldestCommittedSxact();
            LWLockAcquire(SerializableXactHashLock, LW_EXCLUSIVE);
        }
    } while (!sxact);
 
    /* Get the snapshot, or check that it's safe to use */
    if (!sourcevxid)
        snapshot = GetSnapshotData(snapshot);
    else if (!ProcArrayInstallImportedXmin(snapshot->xmin, sourcevxid))
    {
        ReleasePredXact(sxact);
        LWLockRelease(SerializableXactHashLock);
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("could not import the requested snapshot"),
                 errdetail("The source process with PID %d is not running anymore.",
                           sourcepid)));
    }
 
    /*
     * If there are no serializable transactions which are not read-only, we
     * can "opt out" of predicate locking and conflict checking for a
     * read-only transaction.
     *
     * The reason this is safe is that a read-only transaction can only become
     * part of a dangerous structure if it overlaps a writable transaction
     * which in turn overlaps a writable transaction which committed before
     * the read-only transaction started.  A new writable transaction can
     * overlap this one, but it can't meet the other condition of overlapping
     * a transaction which committed before this one started.
     */
    if (XactReadOnly && PredXact->WritableSxactCount == 0)
    {
        ReleasePredXact(sxact);
        LWLockRelease(SerializableXactHashLock);
        return snapshot;
    }
 
    /* Initialize the structure. */
    sxact->vxid = vxid;
    sxact->SeqNo.lastCommitBeforeSnapshot = PredXact->LastSxactCommitSeqNo;
    sxact->prepareSeqNo = InvalidSerCommitSeqNo;
    sxact->commitSeqNo = InvalidSerCommitSeqNo;
    dlist_init(&(sxact->outConflicts));
    dlist_init(&(sxact->inConflicts));
    dlist_init(&(sxact->possibleUnsafeConflicts));
    sxact->topXid = GetTopTransactionIdIfAny();
    sxact->finishedBefore = InvalidTransactionId;
    sxact->xmin = snapshot->xmin;
    sxact->pid = MyProcPid;
    sxact->pgprocno = MyProcNumber;
    dlist_init(&sxact->predicateLocks);
    dlist_node_init(&sxact->finishedLink);
    sxact->flags = 0;
    if (XactReadOnly)
    {
        dlist_iter  iter;
 
        sxact->flags |= SXACT_FLAG_READ_ONLY;
 
        /*
         * Register all concurrent r/w transactions as possible conflicts; if
         * all of them commit without any outgoing conflicts to earlier
         * transactions then this snapshot can be deemed safe (and we can run
         * without tracking predicate locks).
         */
        dlist_foreach(iter, &PredXact->activeList)
        {
            othersxact = dlist_container(SERIALIZABLEXACT, xactLink, iter.cur);
 
            if (!SxactIsCommitted(othersxact)
                && !SxactIsDoomed(othersxact)
                && !SxactIsReadOnly(othersxact))
            {
                SetPossibleUnsafeConflict(sxact, othersxact);
            }
        }
 
        /*
         * If we didn't find any possibly unsafe conflicts because every
         * uncommitted writable transaction turned out to be doomed, then we
         * can "opt out" immediately.  See comments above the earlier check
         * for PredXact->WritableSxactCount == 0.
         */
        if (dlist_is_empty(&sxact->possibleUnsafeConflicts))
        {
            ReleasePredXact(sxact);
            LWLockRelease(SerializableXactHashLock);
            return snapshot;
        }
    }
    else
    {
        ++(PredXact->WritableSxactCount);
        Assert(PredXact->WritableSxactCount <=
               (MaxBackends + max_prepared_xacts));
    }
 
    /* Maintain serializable global xmin info. */
    if (!TransactionIdIsValid(PredXact->SxactGlobalXmin))
    {
        Assert(PredXact->SxactGlobalXminCount == 0);
        PredXact->SxactGlobalXmin = snapshot->xmin;
        PredXact->SxactGlobalXminCount = 1;
        SerialSetActiveSerXmin(snapshot->xmin);
    }
    else if (TransactionIdEquals(snapshot->xmin, PredXact->SxactGlobalXmin))
    {
        Assert(PredXact->SxactGlobalXminCount > 0);
        PredXact->SxactGlobalXminCount++;
    }
    else
    {
        Assert(TransactionIdFollows(snapshot->xmin, PredXact->SxactGlobalXmin));
    }
 
    MySerializableXact = sxact;
    MyXactDidWrite = false;     /* haven't written anything yet */
 
    LWLockRelease(SerializableXactHashLock);
 
    CreateLocalPredicateLockHash();
 
    return snapshot;
}

References PredXactListData::activeList, Assert, SERIALIZABLEXACT::commitSeqNo, CreateLocalPredicateLockHash(), CreatePredXact(), dlist_iter::cur, dlist_container, dlist_foreach, dlist_init(), dlist_is_empty(), dlist_node_init(), elog, ereport, errcode(), errdetail(), errmsg(), ERROR, SERIALIZABLEXACT::finishedBefore, SERIALIZABLEXACT::finishedLink, SERIALIZABLEXACT::flags, GET_VXID_FROM_PGPROC, GetSnapshotData(), GetTopTransactionIdIfAny(), SERIALIZABLEXACT::inConflicts, InvalidSerCommitSeqNo, InvalidSerializableXact, InvalidTransactionId, IsInParallelMode(), SERIALIZABLEXACT::lastCommitBeforeSnapshot, PredXactListData::LastSxactCommitSeqNo, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), max_prepared_xacts, MaxBackends, MyProc, MyProcNumber, MyProcPid, MySerializableXact, MyXactDidWrite, SERIALIZABLEXACT::outConflicts, SERIALIZABLEXACT::pgprocno, SERIALIZABLEXACT::pid, SERIALIZABLEXACT::possibleUnsafeConflicts, SERIALIZABLEXACT::predicateLocks, PredXact, SERIALIZABLEXACT::prepareSeqNo, ProcArrayInstallImportedXmin(), RecoveryInProgress(), ReleasePredXact(), SERIALIZABLEXACT::SeqNo, SerialSetActiveSerXmin(), SetPossibleUnsafeConflict(), SummarizeOldestCommittedSxact(), SXACT_FLAG_READ_ONLY, PredXactListData::SxactGlobalXmin, PredXactListData::SxactGlobalXminCount, SxactIsCommitted, SxactIsDoomed, SxactIsReadOnly, SERIALIZABLEXACT::topXid, TransactionIdEquals, TransactionIdFollows(), TransactionIdIsValid, SERIALIZABLEXACT::vxid, PredXactListData::WritableSxactCount, XactReadOnly, SERIALIZABLEXACT::xmin, and SnapshotData::xmin.

Referenced by GetSafeSnapshot(), GetSerializableTransactionSnapshot(), and SetSerializableTransactionSnapshot().

MaxPredicateChildLocks()

static int MaxPredicateChildLocks ( const PREDICATELOCKTARGETTAG *  tag )

static

Definition at line 2274 of file predicate.c.

{
    switch (GET_PREDICATELOCKTARGETTAG_TYPE(*tag))
    {
        case PREDLOCKTAG_RELATION:
            return max_predicate_locks_per_relation < 0
                ? (max_predicate_locks_per_xact
                   / (-max_predicate_locks_per_relation)) - 1
                : max_predicate_locks_per_relation;
 
        case PREDLOCKTAG_PAGE:
            return max_predicate_locks_per_page;
 
        case PREDLOCKTAG_TUPLE:
 
            /*
             * not reachable: nothing is finer-granularity than a tuple, so we
             * should never try to promote to it.
             */
            Assert(false);
            return 0;
    }
 
    /* not reachable */
    Assert(false);
    return 0;
}

References Assert, GET_PREDICATELOCKTARGETTAG_TYPE, max_predicate_locks_per_page, max_predicate_locks_per_relation, max_predicate_locks_per_xact, PREDLOCKTAG_PAGE, PREDLOCKTAG_RELATION, and PREDLOCKTAG_TUPLE.

Referenced by CheckAndPromotePredicateLockRequest().

OnConflict_CheckForSerializationFailure()

static void OnConflict_CheckForSerializationFailure ( const SERIALIZABLEXACT *  reader, SERIALIZABLEXACT *  writer  )

static

Definition at line 4521 of file predicate.c.

{
    bool        failure;
 
    Assert(LWLockHeldByMe(SerializableXactHashLock));
 
    failure = false;
 
    /*------------------------------------------------------------------------
     * Check for already-committed writer with rw-conflict out flagged
     * (conflict-flag on W means that T2 committed before W):
     *
     *      R ------> W ------> T2
     *          rw        rw
     *
     * That is a dangerous structure, so we must abort. (Since the writer
     * has already committed, we must be the reader)
     *------------------------------------------------------------------------
     */
    if (SxactIsCommitted(writer)
        && (SxactHasConflictOut(writer) || SxactHasSummaryConflictOut(writer)))
        failure = true;
 
    /*------------------------------------------------------------------------
     * Check whether the writer has become a pivot with an out-conflict
     * committed transaction (T2), and T2 committed first:
     *
     *      R ------> W ------> T2
     *          rw        rw
     *
     * Because T2 must've committed first, there is no anomaly if:
     * - the reader committed before T2
     * - the writer committed before T2
     * - the reader is a READ ONLY transaction and the reader was concurrent
     *   with T2 (= reader acquired its snapshot before T2 committed)
     *
     * We also handle the case that T2 is prepared but not yet committed
     * here. In that case T2 has already checked for conflicts, so if it
     * commits first, making the above conflict real, it's too late for it
     * to abort.
     *------------------------------------------------------------------------
     */
    if (!failure && SxactHasSummaryConflictOut(writer))
        failure = true;
    else if (!failure)
    {
        dlist_iter  iter;
 
        dlist_foreach(iter, &writer->outConflicts)
        {
            RWConflict  conflict =
                dlist_container(RWConflictData, outLink, iter.cur);
            SERIALIZABLEXACT *t2 = conflict->sxactIn;
 
            if (SxactIsPrepared(t2)
                && (!SxactIsCommitted(reader)
                    || t2->prepareSeqNo <= reader->commitSeqNo)
                && (!SxactIsCommitted(writer)
                    || t2->prepareSeqNo <= writer->commitSeqNo)
                && (!SxactIsReadOnly(reader)
                    || t2->prepareSeqNo <= reader->SeqNo.lastCommitBeforeSnapshot))
            {
                failure = true;
                break;
            }
        }
    }
 
    /*------------------------------------------------------------------------
     * Check whether the reader has become a pivot with a writer
     * that's committed (or prepared):
     *
     *      T0 ------> R ------> W
     *           rw        rw
     *
     * Because W must've committed first for an anomaly to occur, there is no
     * anomaly if:
     * - T0 committed before the writer
     * - T0 is READ ONLY, and overlaps the writer
     *------------------------------------------------------------------------
     */
    if (!failure && SxactIsPrepared(writer) && !SxactIsReadOnly(reader))
    {
        if (SxactHasSummaryConflictIn(reader))
        {
            failure = true;
        }
        else
        {
            dlist_iter  iter;
 
            /*
             * The unconstify is needed as we have no const version of
             * dlist_foreach().
             */
            dlist_foreach(iter, &unconstify(SERIALIZABLEXACT *, reader)->inConflicts)
            {
                const RWConflict conflict =
                    dlist_container(RWConflictData, inLink, iter.cur);
                const SERIALIZABLEXACT *t0 = conflict->sxactOut;
 
                if (!SxactIsDoomed(t0)
                    && (!SxactIsCommitted(t0)
                        || t0->commitSeqNo >= writer->prepareSeqNo)
                    && (!SxactIsReadOnly(t0)
                        || t0->SeqNo.lastCommitBeforeSnapshot >= writer->prepareSeqNo))
                {
                    failure = true;
                    break;
                }
            }
        }
    }
 
    if (failure)
    {
        /*
         * We have to kill a transaction to avoid a possible anomaly from
         * occurring. If the writer is us, we can just ereport() to cause a
         * transaction abort. Otherwise we flag the writer for termination,
         * causing it to abort when it tries to commit. However, if the writer
         * is a prepared transaction, already prepared, we can't abort it
         * anymore, so we have to kill the reader instead.
         */
        if (MySerializableXact == writer)
        {
            LWLockRelease(SerializableXactHashLock);
            ereport(ERROR,
                    (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
                     errmsg("could not serialize access due to read/write dependencies among transactions"),
                     errdetail_internal("Reason code: Canceled on identification as a pivot, during write."),
                     errhint("The transaction might succeed if retried.")));
        }
        else if (SxactIsPrepared(writer))
        {
            LWLockRelease(SerializableXactHashLock);
 
            /* if we're not the writer, we have to be the reader */
            Assert(MySerializableXact == reader);
            ereport(ERROR,
                    (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
                     errmsg("could not serialize access due to read/write dependencies among transactions"),
                     errdetail_internal("Reason code: Canceled on conflict out to pivot %u, during read.", writer->topXid),
                     errhint("The transaction might succeed if retried.")));
        }
        writer->flags |= SXACT_FLAG_DOOMED;
    }
}

References Assert, SERIALIZABLEXACT::commitSeqNo, dlist_iter::cur, dlist_container, dlist_foreach, ereport, errcode(), ERRCODE_T_R_SERIALIZATION_FAILURE, errdetail_internal(), errhint(), errmsg(), ERROR, SERIALIZABLEXACT::flags, SERIALIZABLEXACT::lastCommitBeforeSnapshot, LWLockHeldByMe(), LWLockRelease(), MySerializableXact, SERIALIZABLEXACT::outConflicts, SERIALIZABLEXACT::prepareSeqNo, SERIALIZABLEXACT::SeqNo, SXACT_FLAG_DOOMED, SxactHasConflictOut, SxactHasSummaryConflictIn, SxactHasSummaryConflictOut, RWConflictData::sxactIn, SxactIsCommitted, SxactIsDoomed, SxactIsPrepared, SxactIsReadOnly, RWConflictData::sxactOut, SERIALIZABLEXACT::topXid, and unconstify.

Referenced by FlagRWConflict().

PageIsPredicateLocked()

bool PageIsPredicateLocked	(	Relation	relation,
		BlockNumber	blkno
	)

Definition at line 1993 of file predicate.c.

{
    PREDICATELOCKTARGETTAG targettag;
    uint32      targettaghash;
    LWLock     *partitionLock;
    PREDICATELOCKTARGET *target;
 
    SET_PREDICATELOCKTARGETTAG_PAGE(targettag,
                                    relation->rd_locator.dbOid,
                                    relation->rd_id,
                                    blkno);
 
    targettaghash = PredicateLockTargetTagHashCode(&targettag);
    partitionLock = PredicateLockHashPartitionLock(targettaghash);
    LWLockAcquire(partitionLock, LW_SHARED);
    target = (PREDICATELOCKTARGET *)
        hash_search_with_hash_value(PredicateLockTargetHash,
                                    &targettag, targettaghash,
                                    HASH_FIND, NULL);
    LWLockRelease(partitionLock);
 
    return (target != NULL);
}

References RelFileLocator::dbOid, HASH_FIND, hash_search_with_hash_value(), LW_SHARED, LWLockAcquire(), LWLockRelease(), PredicateLockHashPartitionLock, PredicateLockTargetHash, PredicateLockTargetTagHashCode, RelationData::rd_id, RelationData::rd_locator, and SET_PREDICATELOCKTARGETTAG_PAGE.

PostPrepare_PredicateLocks()

void PostPrepare_PredicateLocks

(

TransactionId

xid

)

Definition at line 4844 of file predicate.c.

{
    if (MySerializableXact == InvalidSerializableXact)
        return;
 
    Assert(SxactIsPrepared(MySerializableXact));
 
    MySerializableXact->pid = 0;
    MySerializableXact->pgprocno = INVALID_PROC_NUMBER;
 
    hash_destroy(LocalPredicateLockHash);
    LocalPredicateLockHash = NULL;
 
    MySerializableXact = InvalidSerializableXact;
    MyXactDidWrite = false;
}

References Assert, hash_destroy(), INVALID_PROC_NUMBER, InvalidSerializableXact, LocalPredicateLockHash, MySerializableXact, MyXactDidWrite, SERIALIZABLEXACT::pgprocno, SERIALIZABLEXACT::pid, and SxactIsPrepared.

Referenced by PrepareTransaction().

PreCommit_CheckForSerializationFailure()

void PreCommit_CheckForSerializationFailure

(

void

)

Definition at line 4688 of file predicate.c.

{
    dlist_iter  near_iter;
 
    if (MySerializableXact == InvalidSerializableXact)
        return;
 
    Assert(IsolationIsSerializable());
 
    LWLockAcquire(SerializableXactHashLock, LW_EXCLUSIVE);
 
    /*
     * Check if someone else has already decided that we need to die.  Since
     * we set our own DOOMED flag when partially releasing, ignore in that
     * case.
     */
    if (SxactIsDoomed(MySerializableXact) &&
        !SxactIsPartiallyReleased(MySerializableXact))
    {
        LWLockRelease(SerializableXactHashLock);
        ereport(ERROR,
                (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
                 errmsg("could not serialize access due to read/write dependencies among transactions"),
                 errdetail_internal("Reason code: Canceled on identification as a pivot, during commit attempt."),
                 errhint("The transaction might succeed if retried.")));
    }
 
    dlist_foreach(near_iter, &MySerializableXact->inConflicts)
    {
        RWConflict  nearConflict =
            dlist_container(RWConflictData, inLink, near_iter.cur);
 
        if (!SxactIsCommitted(nearConflict->sxactOut)
            && !SxactIsDoomed(nearConflict->sxactOut))
        {
            dlist_iter  far_iter;
 
            dlist_foreach(far_iter, &nearConflict->sxactOut->inConflicts)
            {
                RWConflict  farConflict =
                    dlist_container(RWConflictData, inLink, far_iter.cur);
 
                if (farConflict->sxactOut == MySerializableXact
                    || (!SxactIsCommitted(farConflict->sxactOut)
                        && !SxactIsReadOnly(farConflict->sxactOut)
                        && !SxactIsDoomed(farConflict->sxactOut)))
                {
                    /*
                     * Normally, we kill the pivot transaction to make sure we
                     * make progress if the failing transaction is retried.
                     * However, we can't kill it if it's already prepared, so
                     * in that case we commit suicide instead.
                     */
                    if (SxactIsPrepared(nearConflict->sxactOut))
                    {
                        LWLockRelease(SerializableXactHashLock);
                        ereport(ERROR,
                                (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
                                 errmsg("could not serialize access due to read/write dependencies among transactions"),
                                 errdetail_internal("Reason code: Canceled on commit attempt with conflict in from prepared pivot."),
                                 errhint("The transaction might succeed if retried.")));
                    }
                    nearConflict->sxactOut->flags |= SXACT_FLAG_DOOMED;
                    break;
                }
            }
        }
    }
 
    MySerializableXact->prepareSeqNo = ++(PredXact->LastSxactCommitSeqNo);
    MySerializableXact->flags |= SXACT_FLAG_PREPARED;
 
    LWLockRelease(SerializableXactHashLock);
}

References Assert, dlist_iter::cur, dlist_container, dlist_foreach, ereport, errcode(), ERRCODE_T_R_SERIALIZATION_FAILURE, errdetail_internal(), errhint(), errmsg(), ERROR, SERIALIZABLEXACT::flags, SERIALIZABLEXACT::inConflicts, InvalidSerializableXact, IsolationIsSerializable, PredXactListData::LastSxactCommitSeqNo, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MySerializableXact, PredXact, SERIALIZABLEXACT::prepareSeqNo, SXACT_FLAG_DOOMED, SXACT_FLAG_PREPARED, SxactIsCommitted, SxactIsDoomed, SxactIsPartiallyReleased, SxactIsPrepared, SxactIsReadOnly, and RWConflictData::sxactOut.

Referenced by CommitTransaction(), and PrepareTransaction().

predicatelock_hash()

static uint32 predicatelock_hash ( const void *  key, Size  keysize  )

static

Definition at line 1404 of file predicate.c.

{
    const PREDICATELOCKTAG *predicatelocktag = (const PREDICATELOCKTAG *) key;
    uint32      targethash;
 
    Assert(keysize == sizeof(PREDICATELOCKTAG));
 
    /* Look into the associated target object, and compute its hash code */
    targethash = PredicateLockTargetTagHashCode(&predicatelocktag->myTarget->tag);
 
    return PredicateLockHashCodeFromTargetHashCode(predicatelocktag, targethash);
}

References Assert, sort-test::key, PREDICATELOCKTAG::myTarget, PredicateLockHashCodeFromTargetHashCode, PredicateLockTargetTagHashCode, and PREDICATELOCKTARGET::tag.

Referenced by PredicateLockShmemInit().

predicatelock_twophase_recover()

void predicatelock_twophase_recover	(	TransactionId	xid,
		uint16	info,
		void *	recdata,
		uint32	len
	)

Definition at line 4894 of file predicate.c.

{
    TwoPhasePredicateRecord *record;
 
    Assert(len == sizeof(TwoPhasePredicateRecord));
 
    record = (TwoPhasePredicateRecord *) recdata;
 
    Assert((record->type == TWOPHASEPREDICATERECORD_XACT) ||
           (record->type == TWOPHASEPREDICATERECORD_LOCK));
 
    if (record->type == TWOPHASEPREDICATERECORD_XACT)
    {
        /* Per-transaction record. Set up a SERIALIZABLEXACT. */
        TwoPhasePredicateXactRecord *xactRecord;
        SERIALIZABLEXACT *sxact;
        SERIALIZABLEXID *sxid;
        SERIALIZABLEXIDTAG sxidtag;
        bool        found;
 
        xactRecord = (TwoPhasePredicateXactRecord *) &record->data.xactRecord;
 
        LWLockAcquire(SerializableXactHashLock, LW_EXCLUSIVE);
        sxact = CreatePredXact();
        if (!sxact)
            ereport(ERROR,
                    (errcode(ERRCODE_OUT_OF_MEMORY),
                     errmsg("out of shared memory")));
 
        /* vxid for a prepared xact is INVALID_PROC_NUMBER/xid; no pid */
        sxact->vxid.procNumber = INVALID_PROC_NUMBER;
        sxact->vxid.localTransactionId = (LocalTransactionId) xid;
        sxact->pid = 0;
        sxact->pgprocno = INVALID_PROC_NUMBER;
 
        /* a prepared xact hasn't committed yet */
        sxact->prepareSeqNo = RecoverySerCommitSeqNo;
        sxact->commitSeqNo = InvalidSerCommitSeqNo;
        sxact->finishedBefore = InvalidTransactionId;
 
        sxact->SeqNo.lastCommitBeforeSnapshot = RecoverySerCommitSeqNo;
 
        /*
         * Don't need to track this; no transactions running at the time the
         * recovered xact started are still active, except possibly other
         * prepared xacts and we don't care whether those are RO_SAFE or not.
         */
        dlist_init(&(sxact->possibleUnsafeConflicts));
 
        dlist_init(&(sxact->predicateLocks));
        dlist_node_init(&sxact->finishedLink);
 
        sxact->topXid = xid;
        sxact->xmin = xactRecord->xmin;
        sxact->flags = xactRecord->flags;
        Assert(SxactIsPrepared(sxact));
        if (!SxactIsReadOnly(sxact))
        {
            ++(PredXact->WritableSxactCount);
            Assert(PredXact->WritableSxactCount <=
                   (MaxBackends + max_prepared_xacts));
        }
 
        /*
         * We don't know whether the transaction had any conflicts or not, so
         * we'll conservatively assume that it had both a conflict in and a
         * conflict out, and represent that with the summary conflict flags.
         */
        dlist_init(&(sxact->outConflicts));
        dlist_init(&(sxact->inConflicts));
        sxact->flags |= SXACT_FLAG_SUMMARY_CONFLICT_IN;
        sxact->flags |= SXACT_FLAG_SUMMARY_CONFLICT_OUT;
 
        /* Register the transaction's xid */
        sxidtag.xid = xid;
        sxid = (SERIALIZABLEXID *) hash_search(SerializableXidHash,
                                               &sxidtag,
                                               HASH_ENTER, &found);
        Assert(sxid != NULL);
        Assert(!found);
        sxid->myXact = (SERIALIZABLEXACT *) sxact;
 
        /*
         * Update global xmin. Note that this is a special case compared to
         * registering a normal transaction, because the global xmin might go
         * backwards. That's OK, because until recovery is over we're not
         * going to complete any transactions or create any non-prepared
         * transactions, so there's no danger of throwing away.
         */
        if ((!TransactionIdIsValid(PredXact->SxactGlobalXmin)) ||
            (TransactionIdFollows(PredXact->SxactGlobalXmin, sxact->xmin)))
        {
            PredXact->SxactGlobalXmin = sxact->xmin;
            PredXact->SxactGlobalXminCount = 1;
            SerialSetActiveSerXmin(sxact->xmin);
        }
        else if (TransactionIdEquals(sxact->xmin, PredXact->SxactGlobalXmin))
        {
            Assert(PredXact->SxactGlobalXminCount > 0);
            PredXact->SxactGlobalXminCount++;
        }
 
        LWLockRelease(SerializableXactHashLock);
    }
    else if (record->type == TWOPHASEPREDICATERECORD_LOCK)
    {
        /* Lock record. Recreate the PREDICATELOCK */
        TwoPhasePredicateLockRecord *lockRecord;
        SERIALIZABLEXID *sxid;
        SERIALIZABLEXACT *sxact;
        SERIALIZABLEXIDTAG sxidtag;
        uint32      targettaghash;
 
        lockRecord = (TwoPhasePredicateLockRecord *) &record->data.lockRecord;
        targettaghash = PredicateLockTargetTagHashCode(&lockRecord->target);
 
        LWLockAcquire(SerializableXactHashLock, LW_SHARED);
        sxidtag.xid = xid;
        sxid = (SERIALIZABLEXID *)
            hash_search(SerializableXidHash, &sxidtag, HASH_FIND, NULL);
        LWLockRelease(SerializableXactHashLock);
 
        Assert(sxid != NULL);
        sxact = sxid->myXact;
        Assert(sxact != InvalidSerializableXact);
 
        CreatePredicateLock(&lockRecord->target, targettaghash, sxact);
    }
}

References Assert, SERIALIZABLEXACT::commitSeqNo, CreatePredicateLock(), CreatePredXact(), TwoPhasePredicateRecord::data, dlist_init(), dlist_node_init(), ereport, errcode(), errmsg(), ERROR, SERIALIZABLEXACT::finishedBefore, SERIALIZABLEXACT::finishedLink, SERIALIZABLEXACT::flags, TwoPhasePredicateXactRecord::flags, HASH_ENTER, HASH_FIND, hash_search(), SERIALIZABLEXACT::inConflicts, INVALID_PROC_NUMBER, InvalidSerCommitSeqNo, InvalidSerializableXact, InvalidTransactionId, SERIALIZABLEXACT::lastCommitBeforeSnapshot, len, VirtualTransactionId::localTransactionId, TwoPhasePredicateRecord::lockRecord, LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), max_prepared_xacts, MaxBackends, SERIALIZABLEXID::myXact, SERIALIZABLEXACT::outConflicts, SERIALIZABLEXACT::pgprocno, SERIALIZABLEXACT::pid, SERIALIZABLEXACT::possibleUnsafeConflicts, SERIALIZABLEXACT::predicateLocks, PredicateLockTargetTagHashCode, PredXact, SERIALIZABLEXACT::prepareSeqNo, VirtualTransactionId::procNumber, RecoverySerCommitSeqNo, SERIALIZABLEXACT::SeqNo, SerializableXidHash, SerialSetActiveSerXmin(), SXACT_FLAG_SUMMARY_CONFLICT_IN, SXACT_FLAG_SUMMARY_CONFLICT_OUT, PredXactListData::SxactGlobalXmin, PredXactListData::SxactGlobalXminCount, SxactIsPrepared, SxactIsReadOnly, TwoPhasePredicateLockRecord::target, SERIALIZABLEXACT::topXid, TransactionIdEquals, TransactionIdFollows(), TransactionIdIsValid, TWOPHASEPREDICATERECORD_LOCK, TWOPHASEPREDICATERECORD_XACT, TwoPhasePredicateRecord::type, SERIALIZABLEXACT::vxid, PredXactListData::WritableSxactCount, TwoPhasePredicateRecord::xactRecord, SERIALIZABLEXIDTAG::xid, SERIALIZABLEXACT::xmin, and TwoPhasePredicateXactRecord::xmin.

PredicateLockAcquire()

static void PredicateLockAcquire ( const PREDICATELOCKTARGETTAG *  targettag )

static

Definition at line 2502 of file predicate.c.

{
    uint32      targettaghash;
    bool        found;
    LOCALPREDICATELOCK *locallock;
 
    /* Do we have the lock already, or a covering lock? */
    if (PredicateLockExists(targettag))
        return;
 
    if (CoarserLockCovers(targettag))
        return;
 
    /* the same hash and LW lock apply to the lock target and the local lock. */
    targettaghash = PredicateLockTargetTagHashCode(targettag);
 
    /* Acquire lock in local table */
    locallock = (LOCALPREDICATELOCK *)
        hash_search_with_hash_value(LocalPredicateLockHash,
                                    targettag, targettaghash,
                                    HASH_ENTER, &found);
    locallock->held = true;
    if (!found)
        locallock->childLocks = 0;
 
    /* Actually create the lock */
    CreatePredicateLock(targettag, targettaghash, MySerializableXact);
 
    /*
     * Lock has been acquired. Check whether it should be promoted to a
     * coarser granularity, or whether there are finer-granularity locks to
     * clean up.
     */
    if (CheckAndPromotePredicateLockRequest(targettag))
    {
        /*
         * Lock request was promoted to a coarser-granularity lock, and that
         * lock was acquired. It will delete this lock and any of its
         * children, so we're done.
         */
    }
    else
    {
        /* Clean up any finer-granularity locks */
        if (GET_PREDICATELOCKTARGETTAG_TYPE(*targettag) != PREDLOCKTAG_TUPLE)
            DeleteChildTargetLocks(targettag);
    }
}

References CheckAndPromotePredicateLockRequest(), LOCALPREDICATELOCK::childLocks, CoarserLockCovers(), CreatePredicateLock(), DeleteChildTargetLocks(), GET_PREDICATELOCKTARGETTAG_TYPE, HASH_ENTER, hash_search_with_hash_value(), LOCALPREDICATELOCK::held, LocalPredicateLockHash, MySerializableXact, PredicateLockExists(), PredicateLockTargetTagHashCode, and PREDLOCKTAG_TUPLE.

Referenced by CheckAndPromotePredicateLockRequest(), PredicateLockPage(), PredicateLockRelation(), and PredicateLockTID().

PredicateLockExists()

static bool PredicateLockExists ( const PREDICATELOCKTARGETTAG *  targettag )

static

Definition at line 2030 of file predicate.c.

{
    LOCALPREDICATELOCK *lock;
 
    /* check local hash table */
    lock = (LOCALPREDICATELOCK *) hash_search(LocalPredicateLockHash,
                                              targettag,
                                              HASH_FIND, NULL);
 
    if (!lock)
        return false;
 
    /*
     * Found entry in the table, but still need to check whether it's actually
     * held -- it could just be a parent of some held lock.
     */
    return lock->held;
}

References HASH_FIND, hash_search(), LOCALPREDICATELOCK::held, and LocalPredicateLockHash.

Referenced by CoarserLockCovers(), PredicateLockAcquire(), and PredicateLockTID().

PredicateLockingNeededForRelation()

static bool PredicateLockingNeededForRelation ( Relation  relation )

inlinestatic

Definition at line 498 of file predicate.c.

{
    return !(relation->rd_id < FirstUnpinnedObjectId ||
             RelationUsesLocalBuffers(relation));
}

References FirstUnpinnedObjectId, RelationData::rd_id, and RelationUsesLocalBuffers.

Referenced by DropAllPredicateLocksFromTable(), PredicateLockPageSplit(), SerializationNeededForRead(), and SerializationNeededForWrite().

PredicateLockPage()

void PredicateLockPage	(	Relation	relation,
		BlockNumber	blkno,
		Snapshot	snapshot
	)

Definition at line 2584 of file predicate.c.

{
    PREDICATELOCKTARGETTAG tag;
 
    if (!SerializationNeededForRead(relation, snapshot))
        return;
 
    SET_PREDICATELOCKTARGETTAG_PAGE(tag,
                                    relation->rd_locator.dbOid,
                                    relation->rd_id,
                                    blkno);
    PredicateLockAcquire(&tag);
}

References RelFileLocator::dbOid, PredicateLockAcquire(), RelationData::rd_id, RelationData::rd_locator, SerializationNeededForRead(), and SET_PREDICATELOCKTARGETTAG_PAGE.

Referenced by _bt_endpoint(), _bt_first(), _bt_readnextpage(), _hash_first(), _hash_readnext(), collectMatchBitmap(), gistScanPage(), IndexOnlyNext(), moveRightIfItNeeded(), scanPendingInsert(), and startScanEntry().

PredicateLockPageCombine()

void PredicateLockPageCombine	(	Relation	relation,
		BlockNumber	oldblkno,
		BlockNumber	newblkno
	)

Definition at line 3214 of file predicate.c.

{
    /*
     * Page combines differ from page splits in that we ought to be able to
     * remove the locks on the old page after transferring them to the new
     * page, instead of duplicating them. However, because we can't edit other
     * backends' local lock tables, removing the old lock would leave them
     * with an entry in their LocalPredicateLockHash for a lock they're not
     * holding, which isn't acceptable. So we wind up having to do the same
     * work as a page split, acquiring a lock on the new page and keeping the
     * old page locked too. That can lead to some false positives, but should
     * be rare in practice.
     */
    PredicateLockPageSplit(relation, oldblkno, newblkno);
}

References PredicateLockPageSplit().

Referenced by _bt_mark_page_halfdead(), and ginDeletePage().

PredicateLockPageSplit()

void PredicateLockPageSplit	(	Relation	relation,
		BlockNumber	oldblkno,
		BlockNumber	newblkno
	)

Definition at line 3129 of file predicate.c.

{
    PREDICATELOCKTARGETTAG oldtargettag;
    PREDICATELOCKTARGETTAG newtargettag;
    bool        success;
 
    /*
     * Bail out quickly if there are no serializable transactions running.
     *
     * It's safe to do this check without taking any additional locks. Even if
     * a serializable transaction starts concurrently, we know it can't take
     * any SIREAD locks on the page being split because the caller is holding
     * the associated buffer page lock. Memory reordering isn't an issue; the
     * memory barrier in the LWLock acquisition guarantees that this read
     * occurs while the buffer page lock is held.
     */
    if (!TransactionIdIsValid(PredXact->SxactGlobalXmin))
        return;
 
    if (!PredicateLockingNeededForRelation(relation))
        return;
 
    Assert(oldblkno != newblkno);
    Assert(BlockNumberIsValid(oldblkno));
    Assert(BlockNumberIsValid(newblkno));
 
    SET_PREDICATELOCKTARGETTAG_PAGE(oldtargettag,
                                    relation->rd_locator.dbOid,
                                    relation->rd_id,
                                    oldblkno);
    SET_PREDICATELOCKTARGETTAG_PAGE(newtargettag,
                                    relation->rd_locator.dbOid,
                                    relation->rd_id,
                                    newblkno);
 
    LWLockAcquire(SerializablePredicateListLock, LW_EXCLUSIVE);
 
    /*
     * Try copying the locks over to the new page's tag, creating it if
     * necessary.
     */
    success = TransferPredicateLocksToNewTarget(oldtargettag,
                                                newtargettag,
                                                false);
 
    if (!success)
    {
        /*
         * No more predicate lock entries are available. Failure isn't an
         * option here, so promote the page lock to a relation lock.
         */
 
        /* Get the parent relation lock's lock tag */
        success = GetParentPredicateLockTag(&oldtargettag,
                                            &newtargettag);
        Assert(success);
 
        /*
         * Move the locks to the parent. This shouldn't fail.
         *
         * Note that here we are removing locks held by other backends,
         * leading to a possible inconsistency in their local lock hash table.
         * This is OK because we're replacing it with a lock that covers the
         * old one.
         */
        success = TransferPredicateLocksToNewTarget(oldtargettag,
                                                    newtargettag,
                                                    true);
        Assert(success);
    }
 
    LWLockRelease(SerializablePredicateListLock);
}

References Assert, BlockNumberIsValid(), RelFileLocator::dbOid, GetParentPredicateLockTag(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), PredicateLockingNeededForRelation(), PredXact, RelationData::rd_id, RelationData::rd_locator, SET_PREDICATELOCKTARGETTAG_PAGE, success, PredXactListData::SxactGlobalXmin, TransactionIdIsValid, and TransferPredicateLocksToNewTarget().

Referenced by _bt_insertonpg(), _hash_splitbucket(), createPostingTree(), ginPlaceToPage(), gistplacetopage(), and PredicateLockPageCombine().

PredicateLockRelation()

void PredicateLockRelation	(	Relation	relation,
		Snapshot	snapshot
	)

Definition at line 2561 of file predicate.c.

{
    PREDICATELOCKTARGETTAG tag;
 
    if (!SerializationNeededForRead(relation, snapshot))
        return;
 
    SET_PREDICATELOCKTARGETTAG_RELATION(tag,
                                        relation->rd_locator.dbOid,
                                        relation->rd_id);
    PredicateLockAcquire(&tag);
}

References RelFileLocator::dbOid, PredicateLockAcquire(), RelationData::rd_id, RelationData::rd_locator, SerializationNeededForRead(), and SET_PREDICATELOCKTARGETTAG_RELATION.

Referenced by _bt_endpoint(), _bt_first(), heap_beginscan(), and index_beginscan_internal().

PredicateLockShmemInit()

void PredicateLockShmemInit

(

void

)

Definition at line 1140 of file predicate.c.

{
    HASHCTL     info;
    long        max_table_size;
    Size        requestSize;
    bool        found;
 
#ifndef EXEC_BACKEND
    Assert(!IsUnderPostmaster);
#endif
 
    /*
     * Compute size of predicate lock target hashtable. Note these
     * calculations must agree with PredicateLockShmemSize!
     */
    max_table_size = NPREDICATELOCKTARGETENTS();
 
    /*
     * Allocate hash table for PREDICATELOCKTARGET structs.  This stores
     * per-predicate-lock-target information.
     */
    info.keysize = sizeof(PREDICATELOCKTARGETTAG);
    info.entrysize = sizeof(PREDICATELOCKTARGET);
    info.num_partitions = NUM_PREDICATELOCK_PARTITIONS;
 
    PredicateLockTargetHash = ShmemInitHash("PREDICATELOCKTARGET hash",
                                            max_table_size,
                                            max_table_size,
                                            &info,
                                            HASH_ELEM | HASH_BLOBS |
                                            HASH_PARTITION | HASH_FIXED_SIZE);
 
    /*
     * Reserve a dummy entry in the hash table; we use it to make sure there's
     * always one entry available when we need to split or combine a page,
     * because running out of space there could mean aborting a
     * non-serializable transaction.
     */
    if (!IsUnderPostmaster)
    {
        (void) hash_search(PredicateLockTargetHash, &ScratchTargetTag,
                           HASH_ENTER, &found);
        Assert(!found);
    }
 
    /* Pre-calculate the hash and partition lock of the scratch entry */
    ScratchTargetTagHash = PredicateLockTargetTagHashCode(&ScratchTargetTag);
    ScratchPartitionLock = PredicateLockHashPartitionLock(ScratchTargetTagHash);
 
    /*
     * Allocate hash table for PREDICATELOCK structs.  This stores per
     * xact-lock-of-a-target information.
     */
    info.keysize = sizeof(PREDICATELOCKTAG);
    info.entrysize = sizeof(PREDICATELOCK);
    info.hash = predicatelock_hash;
    info.num_partitions = NUM_PREDICATELOCK_PARTITIONS;
 
    /* Assume an average of 2 xacts per target */
    max_table_size *= 2;
 
    PredicateLockHash = ShmemInitHash("PREDICATELOCK hash",
                                      max_table_size,
                                      max_table_size,
                                      &info,
                                      HASH_ELEM | HASH_FUNCTION |
                                      HASH_PARTITION | HASH_FIXED_SIZE);
 
    /*
     * Compute size for serializable transaction hashtable. Note these
     * calculations must agree with PredicateLockShmemSize!
     */
    max_table_size = (MaxBackends + max_prepared_xacts);
 
    /*
     * Allocate a list to hold information on transactions participating in
     * predicate locking.
     *
     * Assume an average of 10 predicate locking transactions per backend.
     * This allows aggressive cleanup while detail is present before data must
     * be summarized for storage in SLRU and the "dummy" transaction.
     */
    max_table_size *= 10;
 
    PredXact = ShmemInitStruct("PredXactList",
                               PredXactListDataSize,
                               &found);
    Assert(found == IsUnderPostmaster);
    if (!found)
    {
        int         i;
 
        dlist_init(&PredXact->availableList);
        dlist_init(&PredXact->activeList);
        PredXact->SxactGlobalXmin = InvalidTransactionId;
        PredXact->SxactGlobalXminCount = 0;
        PredXact->WritableSxactCount = 0;
        PredXact->LastSxactCommitSeqNo = FirstNormalSerCommitSeqNo - 1;
        PredXact->CanPartialClearThrough = 0;
        PredXact->HavePartialClearedThrough = 0;
        requestSize = mul_size((Size) max_table_size,
                               sizeof(SERIALIZABLEXACT));
        PredXact->element = ShmemAlloc(requestSize);
        /* Add all elements to available list, clean. */
        memset(PredXact->element, 0, requestSize);
        for (i = 0; i < max_table_size; i++)
        {
            LWLockInitialize(&PredXact->element[i].perXactPredicateListLock,
                             LWTRANCHE_PER_XACT_PREDICATE_LIST);
            dlist_push_tail(&PredXact->availableList, &PredXact->element[i].xactLink);
        }
        PredXact->OldCommittedSxact = CreatePredXact();
        SetInvalidVirtualTransactionId(PredXact->OldCommittedSxact->vxid);
        PredXact->OldCommittedSxact->prepareSeqNo = 0;
        PredXact->OldCommittedSxact->commitSeqNo = 0;
        PredXact->OldCommittedSxact->SeqNo.lastCommitBeforeSnapshot = 0;
        dlist_init(&PredXact->OldCommittedSxact->outConflicts);
        dlist_init(&PredXact->OldCommittedSxact->inConflicts);
        dlist_init(&PredXact->OldCommittedSxact->predicateLocks);
        dlist_node_init(&PredXact->OldCommittedSxact->finishedLink);
        dlist_init(&PredXact->OldCommittedSxact->possibleUnsafeConflicts);
        PredXact->OldCommittedSxact->topXid = InvalidTransactionId;
        PredXact->OldCommittedSxact->finishedBefore = InvalidTransactionId;
        PredXact->OldCommittedSxact->xmin = InvalidTransactionId;
        PredXact->OldCommittedSxact->flags = SXACT_FLAG_COMMITTED;
        PredXact->OldCommittedSxact->pid = 0;
        PredXact->OldCommittedSxact->pgprocno = INVALID_PROC_NUMBER;
    }
    /* This never changes, so let's keep a local copy. */
    OldCommittedSxact = PredXact->OldCommittedSxact;
 
    /*
     * Allocate hash table for SERIALIZABLEXID structs.  This stores per-xid
     * information for serializable transactions which have accessed data.
     */
    info.keysize = sizeof(SERIALIZABLEXIDTAG);
    info.entrysize = sizeof(SERIALIZABLEXID);
 
    SerializableXidHash = ShmemInitHash("SERIALIZABLEXID hash",
                                        max_table_size,
                                        max_table_size,
                                        &info,
                                        HASH_ELEM | HASH_BLOBS |
                                        HASH_FIXED_SIZE);
 
    /*
     * Allocate space for tracking rw-conflicts in lists attached to the
     * transactions.
     *
     * Assume an average of 5 conflicts per transaction.  Calculations suggest
     * that this will prevent resource exhaustion in even the most pessimal
     * loads up to max_connections = 200 with all 200 connections pounding the
     * database with serializable transactions.  Beyond that, there may be
     * occasional transactions canceled when trying to flag conflicts. That's
     * probably OK.
     */
    max_table_size *= 5;
 
    RWConflictPool = ShmemInitStruct("RWConflictPool",
                                     RWConflictPoolHeaderDataSize,
                                     &found);
    Assert(found == IsUnderPostmaster);
    if (!found)
    {
        int         i;
 
        dlist_init(&RWConflictPool->availableList);
        requestSize = mul_size((Size) max_table_size,
                               RWConflictDataSize);
        RWConflictPool->element = ShmemAlloc(requestSize);
        /* Add all elements to available list, clean. */
        memset(RWConflictPool->element, 0, requestSize);
        for (i = 0; i < max_table_size; i++)
        {
            dlist_push_tail(&RWConflictPool->availableList,
                            &RWConflictPool->element[i].outLink);
        }
    }
 
    /*
     * Create or attach to the header for the list of finished serializable
     * transactions.
     */
    FinishedSerializableTransactions = (dlist_head *)
        ShmemInitStruct("FinishedSerializableTransactions",
                        sizeof(dlist_head),
                        &found);
    Assert(found == IsUnderPostmaster);
    if (!found)
        dlist_init(FinishedSerializableTransactions);
 
    /*
     * Initialize the SLRU storage for old committed serializable
     * transactions.
     */
    SerialInit();
}

References PredXactListData::activeList, Assert, PredXactListData::availableList, RWConflictPoolHeaderData::availableList, PredXactListData::CanPartialClearThrough, SERIALIZABLEXACT::commitSeqNo, CreatePredXact(), dlist_init(), dlist_node_init(), dlist_push_tail(), PredXactListData::element, RWConflictPoolHeaderData::element, HASHCTL::entrysize, SERIALIZABLEXACT::finishedBefore, SERIALIZABLEXACT::finishedLink, FinishedSerializableTransactions, FirstNormalSerCommitSeqNo, SERIALIZABLEXACT::flags, HASHCTL::hash, HASH_BLOBS, HASH_ELEM, HASH_ENTER, HASH_FIXED_SIZE, HASH_FUNCTION, HASH_PARTITION, hash_search(), PredXactListData::HavePartialClearedThrough, i, SERIALIZABLEXACT::inConflicts, INVALID_PROC_NUMBER, InvalidTransactionId, IsUnderPostmaster, HASHCTL::keysize, SERIALIZABLEXACT::lastCommitBeforeSnapshot, PredXactListData::LastSxactCommitSeqNo, LWLockInitialize(), LWTRANCHE_PER_XACT_PREDICATE_LIST, max_prepared_xacts, MaxBackends, mul_size(), NPREDICATELOCKTARGETENTS, HASHCTL::num_partitions, NUM_PREDICATELOCK_PARTITIONS, OldCommittedSxact, PredXactListData::OldCommittedSxact, SERIALIZABLEXACT::outConflicts, RWConflictData::outLink, SERIALIZABLEXACT::perXactPredicateListLock, SERIALIZABLEXACT::pgprocno, SERIALIZABLEXACT::pid, SERIALIZABLEXACT::possibleUnsafeConflicts, predicatelock_hash(), PredicateLockHash, PredicateLockHashPartitionLock, SERIALIZABLEXACT::predicateLocks, PredicateLockTargetHash, PredicateLockTargetTagHashCode, PredXact, PredXactListDataSize, SERIALIZABLEXACT::prepareSeqNo, RWConflictDataSize, RWConflictPool, RWConflictPoolHeaderDataSize, ScratchPartitionLock, ScratchTargetTag, ScratchTargetTagHash, SERIALIZABLEXACT::SeqNo, SerialInit(), SerializableXidHash, SetInvalidVirtualTransactionId, ShmemAlloc(), ShmemInitHash(), ShmemInitStruct(), SXACT_FLAG_COMMITTED, PredXactListData::SxactGlobalXmin, PredXactListData::SxactGlobalXminCount, SERIALIZABLEXACT::topXid, SERIALIZABLEXACT::vxid, PredXactListData::WritableSxactCount, SERIALIZABLEXACT::xactLink, and SERIALIZABLEXACT::xmin.

Referenced by CreateOrAttachShmemStructs().

PredicateLockShmemSize()

Size PredicateLockShmemSize

(

void

)

Definition at line 1342 of file predicate.c.

{
    Size        size = 0;
    long        max_table_size;
 
    /* predicate lock target hash table */
    max_table_size = NPREDICATELOCKTARGETENTS();
    size = add_size(size, hash_estimate_size(max_table_size,
                                             sizeof(PREDICATELOCKTARGET)));
 
    /* predicate lock hash table */
    max_table_size *= 2;
    size = add_size(size, hash_estimate_size(max_table_size,
                                             sizeof(PREDICATELOCK)));
 
    /*
     * Since NPREDICATELOCKTARGETENTS is only an estimate, add 10% safety
     * margin.
     */
    size = add_size(size, size / 10);
 
    /* transaction list */
    max_table_size = MaxBackends + max_prepared_xacts;
    max_table_size *= 10;
    size = add_size(size, PredXactListDataSize);
    size = add_size(size, mul_size((Size) max_table_size,
                                   sizeof(SERIALIZABLEXACT)));
 
    /* transaction xid table */
    size = add_size(size, hash_estimate_size(max_table_size,
                                             sizeof(SERIALIZABLEXID)));
 
    /* rw-conflict pool */
    max_table_size *= 5;
    size = add_size(size, RWConflictPoolHeaderDataSize);
    size = add_size(size, mul_size((Size) max_table_size,
                                   RWConflictDataSize));
 
    /* Head for list of finished serializable transactions. */
    size = add_size(size, sizeof(dlist_head));
 
    /* Shared memory structures for SLRU tracking of old committed xids. */
    size = add_size(size, sizeof(SerialControlData));
    size = add_size(size, SimpleLruShmemSize(serializable_buffers, 0));
 
    return size;
}

References add_size(), hash_estimate_size(), max_prepared_xacts, MaxBackends, mul_size(), NPREDICATELOCKTARGETENTS, PredXactListDataSize, RWConflictDataSize, RWConflictPoolHeaderDataSize, serializable_buffers, SimpleLruShmemSize(), and size.

Referenced by CalculateShmemSize().

PredicateLockTID()

void PredicateLockTID	(	Relation	relation,
		ItemPointer	tid,
		Snapshot	snapshot,
		TransactionId	tuple_xid
	)

Definition at line 2606 of file predicate.c.

{
    PREDICATELOCKTARGETTAG tag;
 
    if (!SerializationNeededForRead(relation, snapshot))
        return;
 
    /*
     * Return if this xact wrote it.
     */
    if (relation->rd_index == NULL)
    {
        /* If we wrote it; we already have a write lock. */
        if (TransactionIdIsCurrentTransactionId(tuple_xid))
            return;
    }
 
    /*
     * Do quick-but-not-definitive test for a relation lock first.  This will
     * never cause a return when the relation is *not* locked, but will
     * occasionally let the check continue when there really *is* a relation
     * level lock.
     */
    SET_PREDICATELOCKTARGETTAG_RELATION(tag,
                                        relation->rd_locator.dbOid,
                                        relation->rd_id);
    if (PredicateLockExists(&tag))
        return;
 
    SET_PREDICATELOCKTARGETTAG_TUPLE(tag,
                                     relation->rd_locator.dbOid,
                                     relation->rd_id,
                                     ItemPointerGetBlockNumber(tid),
                                     ItemPointerGetOffsetNumber(tid));
    PredicateLockAcquire(&tag);
}

References RelFileLocator::dbOid, ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), PredicateLockAcquire(), PredicateLockExists(), RelationData::rd_id, RelationData::rd_index, RelationData::rd_locator, SerializationNeededForRead(), SET_PREDICATELOCKTARGETTAG_RELATION, SET_PREDICATELOCKTARGETTAG_TUPLE, and TransactionIdIsCurrentTransactionId().

Referenced by heap_fetch(), heap_hot_search_buffer(), and heapam_scan_bitmap_next_block().

PredicateLockTwoPhaseFinish()

void PredicateLockTwoPhaseFinish	(	TransactionId	xid,
		bool	isCommit
	)

Definition at line 4867 of file predicate.c.

{
    SERIALIZABLEXID *sxid;
    SERIALIZABLEXIDTAG sxidtag;
 
    sxidtag.xid = xid;
 
    LWLockAcquire(SerializableXactHashLock, LW_SHARED);
    sxid = (SERIALIZABLEXID *)
        hash_search(SerializableXidHash, &sxidtag, HASH_FIND, NULL);
    LWLockRelease(SerializableXactHashLock);
 
    /* xid will not be found if it wasn't a serializable transaction */
    if (sxid == NULL)
        return;
 
    /* Release its locks */
    MySerializableXact = sxid->myXact;
    MyXactDidWrite = true;      /* conservatively assume that we wrote
                                 * something */
    ReleasePredicateLocks(isCommit, false);
}

References HASH_FIND, hash_search(), LW_SHARED, LWLockAcquire(), LWLockRelease(), MySerializableXact, SERIALIZABLEXID::myXact, MyXactDidWrite, ReleasePredicateLocks(), SerializableXidHash, and SERIALIZABLEXIDTAG::xid.

Referenced by FinishPreparedTransaction().

RegisterPredicateLockingXid()

void RegisterPredicateLockingXid

(

TransactionId

xid

)

Definition at line 1944 of file predicate.c.

{
    SERIALIZABLEXIDTAG sxidtag;
    SERIALIZABLEXID *sxid;
    bool        found;
 
    /*
     * If we're not tracking predicate lock data for this transaction, we
     * should ignore the request and return quickly.
     */
    if (MySerializableXact == InvalidSerializableXact)
        return;
 
    /* We should have a valid XID and be at the top level. */
    Assert(TransactionIdIsValid(xid));
 
    LWLockAcquire(SerializableXactHashLock, LW_EXCLUSIVE);
 
    /* This should only be done once per transaction. */
    Assert(MySerializableXact->topXid == InvalidTransactionId);
 
    MySerializableXact->topXid = xid;
 
    sxidtag.xid = xid;
    sxid = (SERIALIZABLEXID *) hash_search(SerializableXidHash,
                                           &sxidtag,
                                           HASH_ENTER, &found);
    Assert(!found);
 
    /* Initialize the structure. */
    sxid->myXact = MySerializableXact;
    LWLockRelease(SerializableXactHashLock);
}

References Assert, HASH_ENTER, hash_search(), InvalidSerializableXact, InvalidTransactionId, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MySerializableXact, SERIALIZABLEXID::myXact, SerializableXidHash, SERIALIZABLEXACT::topXid, TransactionIdIsValid, and SERIALIZABLEXIDTAG::xid.

Referenced by AssignTransactionId().

ReleaseOneSerializableXact()

static void ReleaseOneSerializableXact ( SERIALIZABLEXACT *  sxact, bool  partial, bool  summarize  )

static

Definition at line 3820 of file predicate.c.

{
    SERIALIZABLEXIDTAG sxidtag;
    dlist_mutable_iter iter;
 
    Assert(sxact != NULL);
    Assert(SxactIsRolledBack(sxact) || SxactIsCommitted(sxact));
    Assert(partial || !SxactIsOnFinishedList(sxact));
    Assert(LWLockHeldByMe(SerializableFinishedListLock));
 
    /*
     * First release all the predicate locks held by this xact (or transfer
     * them to OldCommittedSxact if summarize is true)
     */
    LWLockAcquire(SerializablePredicateListLock, LW_SHARED);
    if (IsInParallelMode())
        LWLockAcquire(&sxact->perXactPredicateListLock, LW_EXCLUSIVE);
    dlist_foreach_modify(iter, &sxact->predicateLocks)
    {
        PREDICATELOCK *predlock =
            dlist_container(PREDICATELOCK, xactLink, iter.cur);
        PREDICATELOCKTAG tag;
        PREDICATELOCKTARGET *target;
        PREDICATELOCKTARGETTAG targettag;
        uint32      targettaghash;
        LWLock     *partitionLock;
 
        tag = predlock->tag;
        target = tag.myTarget;
        targettag = target->tag;
        targettaghash = PredicateLockTargetTagHashCode(&targettag);
        partitionLock = PredicateLockHashPartitionLock(targettaghash);
 
        LWLockAcquire(partitionLock, LW_EXCLUSIVE);
 
        dlist_delete(&predlock->targetLink);
 
        hash_search_with_hash_value(PredicateLockHash, &tag,
                                    PredicateLockHashCodeFromTargetHashCode(&tag,
                                                                            targettaghash),
                                    HASH_REMOVE, NULL);
        if (summarize)
        {
            bool        found;
 
            /* Fold into dummy transaction list. */
            tag.myXact = OldCommittedSxact;
            predlock = hash_search_with_hash_value(PredicateLockHash, &tag,
                                                   PredicateLockHashCodeFromTargetHashCode(&tag,
                                                                                           targettaghash),
                                                   HASH_ENTER_NULL, &found);
            if (!predlock)
                ereport(ERROR,
                        (errcode(ERRCODE_OUT_OF_MEMORY),
                         errmsg("out of shared memory"),
                         errhint("You might need to increase \"%s\".", "max_pred_locks_per_transaction")));
            if (found)
            {
                Assert(predlock->commitSeqNo != 0);
                Assert(predlock->commitSeqNo != InvalidSerCommitSeqNo);
                if (predlock->commitSeqNo < sxact->commitSeqNo)
                    predlock->commitSeqNo = sxact->commitSeqNo;
            }
            else
            {
                dlist_push_tail(&target->predicateLocks,
                                &predlock->targetLink);
                dlist_push_tail(&OldCommittedSxact->predicateLocks,
                                &predlock->xactLink);
                predlock->commitSeqNo = sxact->commitSeqNo;
            }
        }
        else
            RemoveTargetIfNoLongerUsed(target, targettaghash);
 
        LWLockRelease(partitionLock);
    }
 
    /*
     * Rather than retail removal, just re-init the head after we've run
     * through the list.
     */
    dlist_init(&sxact->predicateLocks);
 
    if (IsInParallelMode())
        LWLockRelease(&sxact->perXactPredicateListLock);
    LWLockRelease(SerializablePredicateListLock);
 
    sxidtag.xid = sxact->topXid;
    LWLockAcquire(SerializableXactHashLock, LW_EXCLUSIVE);
 
    /* Release all outConflicts (unless 'partial' is true) */
    if (!partial)
    {
        dlist_foreach_modify(iter, &sxact->outConflicts)
        {
            RWConflict  conflict =
                dlist_container(RWConflictData, outLink, iter.cur);
 
            if (summarize)
                conflict->sxactIn->flags |= SXACT_FLAG_SUMMARY_CONFLICT_IN;
            ReleaseRWConflict(conflict);
        }
    }
 
    /* Release all inConflicts. */
    dlist_foreach_modify(iter, &sxact->inConflicts)
    {
        RWConflict  conflict =
            dlist_container(RWConflictData, inLink, iter.cur);
 
        if (summarize)
            conflict->sxactOut->flags |= SXACT_FLAG_SUMMARY_CONFLICT_OUT;
        ReleaseRWConflict(conflict);
    }
 
    /* Finally, get rid of the xid and the record of the transaction itself. */
    if (!partial)
    {
        if (sxidtag.xid != InvalidTransactionId)
            hash_search(SerializableXidHash, &sxidtag, HASH_REMOVE, NULL);
        ReleasePredXact(sxact);
    }
 
    LWLockRelease(SerializableXactHashLock);
}

References Assert, SERIALIZABLEXACT::commitSeqNo, PREDICATELOCK::commitSeqNo, dlist_mutable_iter::cur, dlist_container, dlist_delete(), dlist_foreach_modify, dlist_init(), dlist_push_tail(), ereport, errcode(), errhint(), errmsg(), ERROR, SERIALIZABLEXACT::flags, HASH_ENTER_NULL, HASH_REMOVE, hash_search(), hash_search_with_hash_value(), SERIALIZABLEXACT::inConflicts, InvalidSerCommitSeqNo, InvalidTransactionId, IsInParallelMode(), LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockHeldByMe(), LWLockRelease(), PREDICATELOCKTAG::myTarget, PREDICATELOCKTAG::myXact, OldCommittedSxact, SERIALIZABLEXACT::outConflicts, SERIALIZABLEXACT::perXactPredicateListLock, PredicateLockHash, PredicateLockHashCodeFromTargetHashCode, PredicateLockHashPartitionLock, SERIALIZABLEXACT::predicateLocks, PREDICATELOCKTARGET::predicateLocks, PredicateLockTargetTagHashCode, ReleasePredXact(), ReleaseRWConflict(), RemoveTargetIfNoLongerUsed(), SerializableXidHash, SXACT_FLAG_SUMMARY_CONFLICT_IN, SXACT_FLAG_SUMMARY_CONFLICT_OUT, RWConflictData::sxactIn, SxactIsCommitted, SxactIsOnFinishedList, SxactIsRolledBack, RWConflictData::sxactOut, PREDICATELOCKTARGET::tag, PREDICATELOCK::tag, PREDICATELOCK::targetLink, SERIALIZABLEXACT::topXid, PREDICATELOCK::xactLink, and SERIALIZABLEXIDTAG::xid.

Referenced by ClearOldPredicateLocks(), ReleasePredicateLocks(), and SummarizeOldestCommittedSxact().

ReleasePredicateLocks()

void ReleasePredicateLocks	(	bool	isCommit,
		bool	isReadOnlySafe
	)

Definition at line 3297 of file predicate.c.

{
    bool        partiallyReleasing = false;
    bool        needToClear;
    SERIALIZABLEXACT *roXact;
    dlist_mutable_iter iter;
 
    /*
     * We can't trust XactReadOnly here, because a transaction which started
     * as READ WRITE can show as READ ONLY later, e.g., within
     * subtransactions.  We want to flag a transaction as READ ONLY if it
     * commits without writing so that de facto READ ONLY transactions get the
     * benefit of some RO optimizations, so we will use this local variable to
     * get some cleanup logic right which is based on whether the transaction
     * was declared READ ONLY at the top level.
     */
    bool        topLevelIsDeclaredReadOnly;
 
    /* We can't be both committing and releasing early due to RO_SAFE. */
    Assert(!(isCommit && isReadOnlySafe));
 
    /* Are we at the end of a transaction, that is, a commit or abort? */
    if (!isReadOnlySafe)
    {
        /*
         * Parallel workers mustn't release predicate locks at the end of
         * their transaction.  The leader will do that at the end of its
         * transaction.
         */
        if (IsParallelWorker())
        {
            ReleasePredicateLocksLocal();
            return;
        }
 
        /*
         * By the time the leader in a parallel query reaches end of
         * transaction, it has waited for all workers to exit.
         */
        Assert(!ParallelContextActive());
 
        /*
         * If the leader in a parallel query earlier stashed a partially
         * released SERIALIZABLEXACT for final clean-up at end of transaction
         * (because workers might still have been accessing it), then it's
         * time to restore it.
         */
        if (SavedSerializableXact != InvalidSerializableXact)
        {
            Assert(MySerializableXact == InvalidSerializableXact);
            MySerializableXact = SavedSerializableXact;
            SavedSerializableXact = InvalidSerializableXact;
            Assert(SxactIsPartiallyReleased(MySerializableXact));
        }
    }
 
    if (MySerializableXact == InvalidSerializableXact)
    {
        Assert(LocalPredicateLockHash == NULL);
        return;
    }
 
    LWLockAcquire(SerializableXactHashLock, LW_EXCLUSIVE);
 
    /*
     * If the transaction is committing, but it has been partially released
     * already, then treat this as a roll back.  It was marked as rolled back.
     */
    if (isCommit && SxactIsPartiallyReleased(MySerializableXact))
        isCommit = false;
 
    /*
     * If we're called in the middle of a transaction because we discovered
     * that the SXACT_FLAG_RO_SAFE flag was set, then we'll partially release
     * it (that is, release the predicate locks and conflicts, but not the
     * SERIALIZABLEXACT itself) if we're the first backend to have noticed.
     */
    if (isReadOnlySafe && IsInParallelMode())
    {
        /*
         * The leader needs to stash a pointer to it, so that it can
         * completely release it at end-of-transaction.
         */
        if (!IsParallelWorker())
            SavedSerializableXact = MySerializableXact;
 
        /*
         * The first backend to reach this condition will partially release
         * the SERIALIZABLEXACT.  All others will just clear their
         * backend-local state so that they stop doing SSI checks for the rest
         * of the transaction.
         */
        if (SxactIsPartiallyReleased(MySerializableXact))
        {
            LWLockRelease(SerializableXactHashLock);
            ReleasePredicateLocksLocal();
            return;
        }
        else
        {
            MySerializableXact->flags |= SXACT_FLAG_PARTIALLY_RELEASED;
            partiallyReleasing = true;
            /* ... and proceed to perform the partial release below. */
        }
    }
    Assert(!isCommit || SxactIsPrepared(MySerializableXact));
    Assert(!isCommit || !SxactIsDoomed(MySerializableXact));
    Assert(!SxactIsCommitted(MySerializableXact));
    Assert(SxactIsPartiallyReleased(MySerializableXact)
           || !SxactIsRolledBack(MySerializableXact));
 
    /* may not be serializable during COMMIT/ROLLBACK PREPARED */
    Assert(MySerializableXact->pid == 0 || IsolationIsSerializable());
 
    /* We'd better not already be on the cleanup list. */
    Assert(!SxactIsOnFinishedList(MySerializableXact));
 
    topLevelIsDeclaredReadOnly = SxactIsReadOnly(MySerializableXact);
 
    /*
     * We don't hold XidGenLock lock here, assuming that TransactionId is
     * atomic!
     *
     * If this value is changing, we don't care that much whether we get the
     * old or new value -- it is just used to determine how far
     * SxactGlobalXmin must advance before this transaction can be fully
     * cleaned up.  The worst that could happen is we wait for one more
     * transaction to complete before freeing some RAM; correctness of visible
     * behavior is not affected.
     */
    MySerializableXact->finishedBefore = XidFromFullTransactionId(TransamVariables->nextXid);
 
    /*
     * If it's not a commit it's either a rollback or a read-only transaction
     * flagged SXACT_FLAG_RO_SAFE, and we can clear our locks immediately.
     */
    if (isCommit)
    {
        MySerializableXact->flags |= SXACT_FLAG_COMMITTED;
        MySerializableXact->commitSeqNo = ++(PredXact->LastSxactCommitSeqNo);
        /* Recognize implicit read-only transaction (commit without write). */
        if (!MyXactDidWrite)
            MySerializableXact->flags |= SXACT_FLAG_READ_ONLY;
    }
    else
    {
        /*
         * The DOOMED flag indicates that we intend to roll back this
         * transaction and so it should not cause serialization failures for
         * other transactions that conflict with it. Note that this flag might
         * already be set, if another backend marked this transaction for
         * abort.
         *
         * The ROLLED_BACK flag further indicates that ReleasePredicateLocks
         * has been called, and so the SerializableXact is eligible for
         * cleanup. This means it should not be considered when calculating
         * SxactGlobalXmin.
         */
        MySerializableXact->flags |= SXACT_FLAG_DOOMED;
        MySerializableXact->flags |= SXACT_FLAG_ROLLED_BACK;
 
        /*
         * If the transaction was previously prepared, but is now failing due
         * to a ROLLBACK PREPARED or (hopefully very rare) error after the
         * prepare, clear the prepared flag.  This simplifies conflict
         * checking.
         */
        MySerializableXact->flags &= ~SXACT_FLAG_PREPARED;
    }
 
    if (!topLevelIsDeclaredReadOnly)
    {
        Assert(PredXact->WritableSxactCount > 0);
        if (--(PredXact->WritableSxactCount) == 0)
        {
            /*
             * Release predicate locks and rw-conflicts in for all committed
             * transactions.  There are no longer any transactions which might
             * conflict with the locks and no chance for new transactions to
             * overlap.  Similarly, existing conflicts in can't cause pivots,
             * and any conflicts in which could have completed a dangerous
             * structure would already have caused a rollback, so any
             * remaining ones must be benign.
             */
            PredXact->CanPartialClearThrough = PredXact->LastSxactCommitSeqNo;
        }
    }
    else
    {
        /*
         * Read-only transactions: clear the list of transactions that might
         * make us unsafe. Note that we use 'inLink' for the iteration as
         * opposed to 'outLink' for the r/w xacts.
         */
        dlist_foreach_modify(iter, &MySerializableXact->possibleUnsafeConflicts)
        {
            RWConflict  possibleUnsafeConflict =
                dlist_container(RWConflictData, inLink, iter.cur);
 
            Assert(!SxactIsReadOnly(possibleUnsafeConflict->sxactOut));
            Assert(MySerializableXact == possibleUnsafeConflict->sxactIn);
 
            ReleaseRWConflict(possibleUnsafeConflict);
        }
    }
 
    /* Check for conflict out to old committed transactions. */
    if (isCommit
        && !SxactIsReadOnly(MySerializableXact)
        && SxactHasSummaryConflictOut(MySerializableXact))
    {
        /*
         * we don't know which old committed transaction we conflicted with,
         * so be conservative and use FirstNormalSerCommitSeqNo here
         */
        MySerializableXact->SeqNo.earliestOutConflictCommit =
            FirstNormalSerCommitSeqNo;
        MySerializableXact->flags |= SXACT_FLAG_CONFLICT_OUT;
    }
 
    /*
     * Release all outConflicts to committed transactions.  If we're rolling
     * back clear them all.  Set SXACT_FLAG_CONFLICT_OUT if any point to
     * previously committed transactions.
     */
    dlist_foreach_modify(iter, &MySerializableXact->outConflicts)
    {
        RWConflict  conflict =
            dlist_container(RWConflictData, outLink, iter.cur);
 
        if (isCommit
            && !SxactIsReadOnly(MySerializableXact)
            && SxactIsCommitted(conflict->sxactIn))
        {
            if ((MySerializableXact->flags & SXACT_FLAG_CONFLICT_OUT) == 0
                || conflict->sxactIn->prepareSeqNo < MySerializableXact->SeqNo.earliestOutConflictCommit)
                MySerializableXact->SeqNo.earliestOutConflictCommit = conflict->sxactIn->prepareSeqNo;
            MySerializableXact->flags |= SXACT_FLAG_CONFLICT_OUT;
        }
 
        if (!isCommit
            || SxactIsCommitted(conflict->sxactIn)
            || (conflict->sxactIn->SeqNo.lastCommitBeforeSnapshot >= PredXact->LastSxactCommitSeqNo))
            ReleaseRWConflict(conflict);
    }
 
    /*
     * Release all inConflicts from committed and read-only transactions. If
     * we're rolling back, clear them all.
     */
    dlist_foreach_modify(iter, &MySerializableXact->inConflicts)
    {
        RWConflict  conflict =
            dlist_container(RWConflictData, inLink, iter.cur);
 
        if (!isCommit
            || SxactIsCommitted(conflict->sxactOut)
            || SxactIsReadOnly(conflict->sxactOut))
            ReleaseRWConflict(conflict);
    }
 
    if (!topLevelIsDeclaredReadOnly)
    {
        /*
         * Remove ourselves from the list of possible conflicts for concurrent
         * READ ONLY transactions, flagging them as unsafe if we have a
         * conflict out. If any are waiting DEFERRABLE transactions, wake them
         * up if they are known safe or known unsafe.
         */
        dlist_foreach_modify(iter, &MySerializableXact->possibleUnsafeConflicts)
        {
            RWConflict  possibleUnsafeConflict =
                dlist_container(RWConflictData, outLink, iter.cur);
 
            roXact = possibleUnsafeConflict->sxactIn;
            Assert(MySerializableXact == possibleUnsafeConflict->sxactOut);
            Assert(SxactIsReadOnly(roXact));
 
            /* Mark conflicted if necessary. */
            if (isCommit
                && MyXactDidWrite
                && SxactHasConflictOut(MySerializableXact)
                && (MySerializableXact->SeqNo.earliestOutConflictCommit
                    <= roXact->SeqNo.lastCommitBeforeSnapshot))
            {
                /*
                 * This releases possibleUnsafeConflict (as well as all other
                 * possible conflicts for roXact)
                 */
                FlagSxactUnsafe(roXact);
            }
            else
            {
                ReleaseRWConflict(possibleUnsafeConflict);
 
                /*
                 * If we were the last possible conflict, flag it safe. The
                 * transaction can now safely release its predicate locks (but
                 * that transaction's backend has to do that itself).
                 */
                if (dlist_is_empty(&roXact->possibleUnsafeConflicts))
                    roXact->flags |= SXACT_FLAG_RO_SAFE;
            }
 
            /*
             * Wake up the process for a waiting DEFERRABLE transaction if we
             * now know it's either safe or conflicted.
             */
            if (SxactIsDeferrableWaiting(roXact) &&
                (SxactIsROUnsafe(roXact) || SxactIsROSafe(roXact)))
                ProcSendSignal(roXact->pgprocno);
        }
    }
 
    /*
     * Check whether it's time to clean up old transactions. This can only be
     * done when the last serializable transaction with the oldest xmin among
     * serializable transactions completes.  We then find the "new oldest"
     * xmin and purge any transactions which finished before this transaction
     * was launched.
     *
     * For parallel queries in read-only transactions, it might run twice. We
     * only release the reference on the first call.
     */
    needToClear = false;
    if ((partiallyReleasing ||
         !SxactIsPartiallyReleased(MySerializableXact)) &&
        TransactionIdEquals(MySerializableXact->xmin,
                            PredXact->SxactGlobalXmin))
    {
        Assert(PredXact->SxactGlobalXminCount > 0);
        if (--(PredXact->SxactGlobalXminCount) == 0)
        {
            SetNewSxactGlobalXmin();
            needToClear = true;
        }
    }
 
    LWLockRelease(SerializableXactHashLock);
 
    LWLockAcquire(SerializableFinishedListLock, LW_EXCLUSIVE);
 
    /* Add this to the list of transactions to check for later cleanup. */
    if (isCommit)
        dlist_push_tail(FinishedSerializableTransactions,
                        &MySerializableXact->finishedLink);
 
    /*
     * If we're releasing a RO_SAFE transaction in parallel mode, we'll only
     * partially release it.  That's necessary because other backends may have
     * a reference to it.  The leader will release the SERIALIZABLEXACT itself
     * at the end of the transaction after workers have stopped running.
     */
    if (!isCommit)
        ReleaseOneSerializableXact(MySerializableXact,
                                   isReadOnlySafe && IsInParallelMode(),
                                   false);
 
    LWLockRelease(SerializableFinishedListLock);
 
    if (needToClear)
        ClearOldPredicateLocks();
 
    ReleasePredicateLocksLocal();
}

References Assert, PredXactListData::CanPartialClearThrough, ClearOldPredicateLocks(), SERIALIZABLEXACT::commitSeqNo, dlist_mutable_iter::cur, dlist_container, dlist_foreach_modify, dlist_is_empty(), dlist_push_tail(), SERIALIZABLEXACT::earliestOutConflictCommit, SERIALIZABLEXACT::finishedBefore, SERIALIZABLEXACT::finishedLink, FinishedSerializableTransactions, FirstNormalSerCommitSeqNo, SERIALIZABLEXACT::flags, FlagSxactUnsafe(), SERIALIZABLEXACT::inConflicts, InvalidSerializableXact, IsInParallelMode(), IsolationIsSerializable, IsParallelWorker, SERIALIZABLEXACT::lastCommitBeforeSnapshot, PredXactListData::LastSxactCommitSeqNo, LocalPredicateLockHash, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MySerializableXact, MyXactDidWrite, TransamVariablesData::nextXid, SERIALIZABLEXACT::outConflicts, ParallelContextActive(), SERIALIZABLEXACT::pgprocno, SERIALIZABLEXACT::pid, SERIALIZABLEXACT::possibleUnsafeConflicts, PredXact, SERIALIZABLEXACT::prepareSeqNo, ProcSendSignal(), ReleaseOneSerializableXact(), ReleasePredicateLocksLocal(), ReleaseRWConflict(), SavedSerializableXact, SERIALIZABLEXACT::SeqNo, SetNewSxactGlobalXmin(), SXACT_FLAG_COMMITTED, SXACT_FLAG_CONFLICT_OUT, SXACT_FLAG_DOOMED, SXACT_FLAG_PARTIALLY_RELEASED, SXACT_FLAG_PREPARED, SXACT_FLAG_READ_ONLY, SXACT_FLAG_RO_SAFE, SXACT_FLAG_ROLLED_BACK, PredXactListData::SxactGlobalXmin, PredXactListData::SxactGlobalXminCount, SxactHasConflictOut, SxactHasSummaryConflictOut, RWConflictData::sxactIn, SxactIsCommitted, SxactIsDeferrableWaiting, SxactIsDoomed, SxactIsOnFinishedList, SxactIsPartiallyReleased, SxactIsPrepared, SxactIsReadOnly, SxactIsRolledBack, SxactIsROSafe, SxactIsROUnsafe, RWConflictData::sxactOut, TransactionIdEquals, TransamVariables, PredXactListData::WritableSxactCount, XidFromFullTransactionId, and SERIALIZABLEXACT::xmin.

Referenced by GetSafeSnapshot(), PredicateLockTwoPhaseFinish(), ResourceOwnerReleaseInternal(), and SerializationNeededForRead().

ReleasePredicateLocksLocal()

static void ReleasePredicateLocksLocal ( void  )

static

Definition at line 3664 of file predicate.c.

{
    MySerializableXact = InvalidSerializableXact;
    MyXactDidWrite = false;
 
    /* Delete per-transaction lock table */
    if (LocalPredicateLockHash != NULL)
    {
        hash_destroy(LocalPredicateLockHash);
        LocalPredicateLockHash = NULL;
    }
}

References hash_destroy(), InvalidSerializableXact, LocalPredicateLockHash, MySerializableXact, and MyXactDidWrite.

Referenced by ReleasePredicateLocks().

ReleasePredXact()

static void ReleasePredXact ( SERIALIZABLEXACT *  sxact )

static

Definition at line 596 of file predicate.c.

{
    Assert(ShmemAddrIsValid(sxact));
 
    dlist_delete(&sxact->xactLink);
    dlist_push_tail(&PredXact->availableList, &sxact->xactLink);
}

References Assert, PredXactListData::availableList, dlist_delete(), dlist_push_tail(), PredXact, ShmemAddrIsValid(), and SERIALIZABLEXACT::xactLink.

Referenced by GetSerializableTransactionSnapshotInt(), and ReleaseOneSerializableXact().

ReleaseRWConflict()

static void ReleaseRWConflict ( RWConflict  conflict )

static

Definition at line 691 of file predicate.c.

{
    dlist_delete(&conflict->inLink);
    dlist_delete(&conflict->outLink);
    dlist_push_tail(&RWConflictPool->availableList, &conflict->outLink);
}

References RWConflictPoolHeaderData::availableList, dlist_delete(), dlist_push_tail(), RWConflictData::inLink, RWConflictData::outLink, and RWConflictPool.

Referenced by FlagSxactUnsafe(), ReleaseOneSerializableXact(), and ReleasePredicateLocks().

RemoveScratchTarget()

static void RemoveScratchTarget ( bool  lockheld )

static

Definition at line 2125 of file predicate.c.

{
    bool        found;
 
    Assert(LWLockHeldByMe(SerializablePredicateListLock));
 
    if (!lockheld)
        LWLockAcquire(ScratchPartitionLock, LW_EXCLUSIVE);
    hash_search_with_hash_value(PredicateLockTargetHash,
                                &ScratchTargetTag,
                                ScratchTargetTagHash,
                                HASH_REMOVE, &found);
    Assert(found);
    if (!lockheld)
        LWLockRelease(ScratchPartitionLock);
}

References Assert, HASH_REMOVE, hash_search_with_hash_value(), LW_EXCLUSIVE, LWLockAcquire(), LWLockHeldByMe(), LWLockRelease(), PredicateLockTargetHash, ScratchPartitionLock, ScratchTargetTag, and ScratchTargetTagHash.

Referenced by DropAllPredicateLocksFromTable(), and TransferPredicateLocksToNewTarget().

RemoveTargetIfNoLongerUsed()

static void RemoveTargetIfNoLongerUsed ( PREDICATELOCKTARGET *  target, uint32  targettaghash  )

static

Definition at line 2168 of file predicate.c.

{
    PREDICATELOCKTARGET *rmtarget PG_USED_FOR_ASSERTS_ONLY;
 
    Assert(LWLockHeldByMe(SerializablePredicateListLock));
 
    /* Can't remove it until no locks at this target. */
    if (!dlist_is_empty(&target->predicateLocks))
        return;
 
    /* Actually remove the target. */
    rmtarget = hash_search_with_hash_value(PredicateLockTargetHash,
                                           &target->tag,
                                           targettaghash,
                                           HASH_REMOVE, NULL);
    Assert(rmtarget == target);
}

References Assert, dlist_is_empty(), HASH_REMOVE, hash_search_with_hash_value(), LWLockHeldByMe(), PG_USED_FOR_ASSERTS_ONLY, PREDICATELOCKTARGET::predicateLocks, PredicateLockTargetHash, and PREDICATELOCKTARGET::tag.

Referenced by CheckTargetForConflictsIn(), ClearOldPredicateLocks(), DeleteChildTargetLocks(), DeleteLockTarget(), ReleaseOneSerializableXact(), and TransferPredicateLocksToNewTarget().

RestoreScratchTarget()

static void RestoreScratchTarget ( bool  lockheld )

static

Definition at line 2146 of file predicate.c.

{
    bool        found;
 
    Assert(LWLockHeldByMe(SerializablePredicateListLock));
 
    if (!lockheld)
        LWLockAcquire(ScratchPartitionLock, LW_EXCLUSIVE);
    hash_search_with_hash_value(PredicateLockTargetHash,
                                &ScratchTargetTag,
                                ScratchTargetTagHash,
                                HASH_ENTER, &found);
    Assert(!found);
    if (!lockheld)
        LWLockRelease(ScratchPartitionLock);
}

References Assert, HASH_ENTER, hash_search_with_hash_value(), LW_EXCLUSIVE, LWLockAcquire(), LWLockHeldByMe(), LWLockRelease(), PredicateLockTargetHash, ScratchPartitionLock, ScratchTargetTag, and ScratchTargetTagHash.

Referenced by DropAllPredicateLocksFromTable(), and TransferPredicateLocksToNewTarget().

RWConflictExists()

static bool RWConflictExists ( const SERIALIZABLEXACT *  reader, const SERIALIZABLEXACT *  writer  )

static

Definition at line 610 of file predicate.c.

{
    dlist_iter  iter;
 
    Assert(reader != writer);
 
    /* Check the ends of the purported conflict first. */
    if (SxactIsDoomed(reader)
        || SxactIsDoomed(writer)
        || dlist_is_empty(&reader->outConflicts)
        || dlist_is_empty(&writer->inConflicts))
        return false;
 
    /*
     * A conflict is possible; walk the list to find out.
     *
     * The unconstify is needed as we have no const version of
     * dlist_foreach().
     */
    dlist_foreach(iter, &unconstify(SERIALIZABLEXACT *, reader)->outConflicts)
    {
        RWConflict  conflict =
            dlist_container(RWConflictData, outLink, iter.cur);
 
        if (conflict->sxactIn == writer)
            return true;
    }
 
    /* No conflict found. */
    return false;
}

References Assert, dlist_iter::cur, dlist_container, dlist_foreach, dlist_is_empty(), SERIALIZABLEXACT::inConflicts, SERIALIZABLEXACT::outConflicts, RWConflictData::sxactIn, SxactIsDoomed, and unconstify.

Referenced by CheckForSerializableConflictOut(), CheckTableForSerializableConflictIn(), CheckTargetForConflictsIn(), and SetRWConflict().

SerialAdd()

static void SerialAdd ( TransactionId  xid, SerCommitSeqNo  minConflictCommitSeqNo  )

static

Definition at line 858 of file predicate.c.

{
    TransactionId tailXid;
    int64       targetPage;
    int         slotno;
    int64       firstZeroPage;
    bool        isNewPage;
    LWLock     *lock;
 
    Assert(TransactionIdIsValid(xid));
 
    targetPage = SerialPage(xid);
    lock = SimpleLruGetBankLock(SerialSlruCtl, targetPage);
 
    /*
     * In this routine, we must hold both SerialControlLock and the SLRU bank
     * lock simultaneously while making the SLRU data catch up with the new
     * state that we determine.
     */
    LWLockAcquire(SerialControlLock, LW_EXCLUSIVE);
 
    /*
     * If no serializable transactions are active, there shouldn't be anything
     * to push out to the SLRU.  Hitting this assert would mean there's
     * something wrong with the earlier cleanup logic.
     */
    tailXid = serialControl->tailXid;
    Assert(TransactionIdIsValid(tailXid));
 
    /*
     * If the SLRU is currently unused, zero out the whole active region from
     * tailXid to headXid before taking it into use. Otherwise zero out only
     * any new pages that enter the tailXid-headXid range as we advance
     * headXid.
     */
    if (serialControl->headPage < 0)
    {
        firstZeroPage = SerialPage(tailXid);
        isNewPage = true;
    }
    else
    {
        firstZeroPage = SerialNextPage(serialControl->headPage);
        isNewPage = SerialPagePrecedesLogically(serialControl->headPage,
                                                targetPage);
    }
 
    if (!TransactionIdIsValid(serialControl->headXid)
        || TransactionIdFollows(xid, serialControl->headXid))
        serialControl->headXid = xid;
    if (isNewPage)
        serialControl->headPage = targetPage;
 
    if (isNewPage)
    {
        /* Initialize intervening pages; might involve trading locks */
        for (;;)
        {
            lock = SimpleLruGetBankLock(SerialSlruCtl, firstZeroPage);
            LWLockAcquire(lock, LW_EXCLUSIVE);
            slotno = SimpleLruZeroPage(SerialSlruCtl, firstZeroPage);
            if (firstZeroPage == targetPage)
                break;
            firstZeroPage = SerialNextPage(firstZeroPage);
            LWLockRelease(lock);
        }
    }
    else
    {
        LWLockAcquire(lock, LW_EXCLUSIVE);
        slotno = SimpleLruReadPage(SerialSlruCtl, targetPage, true, xid);
    }
 
    SerialValue(slotno, xid) = minConflictCommitSeqNo;
    SerialSlruCtl->shared->page_dirty[slotno] = true;
 
    LWLockRelease(lock);
    LWLockRelease(SerialControlLock);
}

References Assert, SerialControlData::headPage, SerialControlData::headXid, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), serialControl, SerialNextPage, SerialPage, SerialPagePrecedesLogically(), SerialSlruCtl, SerialValue, SimpleLruGetBankLock(), SimpleLruReadPage(), SimpleLruZeroPage(), SerialControlData::tailXid, TransactionIdFollows(), and TransactionIdIsValid.

Referenced by SummarizeOldestCommittedSxact().

SerialGetMinConflictCommitSeqNo()

static SerCommitSeqNo SerialGetMinConflictCommitSeqNo ( TransactionId  xid )

static

Definition at line 944 of file predicate.c.

{
    TransactionId headXid;
    TransactionId tailXid;
    SerCommitSeqNo val;
    int         slotno;
 
    Assert(TransactionIdIsValid(xid));
 
    LWLockAcquire(SerialControlLock, LW_SHARED);
    headXid = serialControl->headXid;
    tailXid = serialControl->tailXid;
    LWLockRelease(SerialControlLock);
 
    if (!TransactionIdIsValid(headXid))
        return 0;
 
    Assert(TransactionIdIsValid(tailXid));
 
    if (TransactionIdPrecedes(xid, tailXid)
        || TransactionIdFollows(xid, headXid))
        return 0;
 
    /*
     * The following function must be called without holding SLRU bank lock,
     * but will return with that lock held, which must then be released.
     */
    slotno = SimpleLruReadPage_ReadOnly(SerialSlruCtl,
                                        SerialPage(xid), xid);
    val = SerialValue(slotno, xid);
    LWLockRelease(SimpleLruGetBankLock(SerialSlruCtl, SerialPage(xid)));
    return val;
}

References Assert, SerialControlData::headXid, LW_SHARED, LWLockAcquire(), LWLockRelease(), serialControl, SerialPage, SerialSlruCtl, SerialValue, SimpleLruGetBankLock(), SimpleLruReadPage_ReadOnly(), SerialControlData::tailXid, TransactionIdFollows(), TransactionIdIsValid, TransactionIdPrecedes(), and val.

Referenced by CheckForSerializableConflictOut().

SerialInit()

static void SerialInit ( void  )

static

Definition at line 806 of file predicate.c.

{
    bool        found;
 
    /*
     * Set up SLRU management of the pg_serial data.
     */
    SerialSlruCtl->PagePrecedes = SerialPagePrecedesLogically;
    SimpleLruInit(SerialSlruCtl, "serializable",
                  serializable_buffers, 0, "pg_serial",
                  LWTRANCHE_SERIAL_BUFFER, LWTRANCHE_SERIAL_SLRU,
                  SYNC_HANDLER_NONE, false);
#ifdef USE_ASSERT_CHECKING
    SerialPagePrecedesLogicallyUnitTests();
#endif
    SlruPagePrecedesUnitTests(SerialSlruCtl, SERIAL_ENTRIESPERPAGE);
 
    /*
     * Create or attach to the SerialControl structure.
     */
    serialControl = (SerialControl)
        ShmemInitStruct("SerialControlData", sizeof(SerialControlData), &found);
 
    Assert(found == IsUnderPostmaster);
    if (!found)
    {
        /*
         * Set control information to reflect empty SLRU.
         */
        LWLockAcquire(SerialControlLock, LW_EXCLUSIVE);
        serialControl->headPage = -1;
        serialControl->headXid = InvalidTransactionId;
        serialControl->tailXid = InvalidTransactionId;
        LWLockRelease(SerialControlLock);
    }
}

References Assert, SerialControlData::headPage, SerialControlData::headXid, InvalidTransactionId, IsUnderPostmaster, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), LWTRANCHE_SERIAL_BUFFER, LWTRANCHE_SERIAL_SLRU, SERIAL_ENTRIESPERPAGE, serialControl, serializable_buffers, SerialPagePrecedesLogically(), SerialSlruCtl, ShmemInitStruct(), SimpleLruInit(), SlruPagePrecedesUnitTests, SYNC_HANDLER_NONE, and SerialControlData::tailXid.

Referenced by PredicateLockShmemInit().

SerializationNeededForRead()

static bool SerializationNeededForRead ( Relation  relation, Snapshot  snapshot  )

inlinestatic

Definition at line 516 of file predicate.c.

{
    /* Nothing to do if this is not a serializable transaction */
    if (MySerializableXact == InvalidSerializableXact)
        return false;
 
    /*
     * Don't acquire locks or conflict when scanning with a special snapshot.
     * This excludes things like CLUSTER and REINDEX. They use the wholesale
     * functions TransferPredicateLocksToHeapRelation() and
     * CheckTableForSerializableConflictIn() to participate in serialization,
     * but the scans involved don't need serialization.
     */
    if (!IsMVCCSnapshot(snapshot))
        return false;
 
    /*
     * Check if we have just become "RO-safe". If we have, immediately release
     * all locks as they're not needed anymore. This also resets
     * MySerializableXact, so that subsequent calls to this function can exit
     * quickly.
     *
     * A transaction is flagged as RO_SAFE if all concurrent R/W transactions
     * commit without having conflicts out to an earlier snapshot, thus
     * ensuring that no conflicts are possible for this transaction.
     */
    if (SxactIsROSafe(MySerializableXact))
    {
        ReleasePredicateLocks(false, true);
        return false;
    }
 
    /* Check if the relation doesn't participate in predicate locking */
    if (!PredicateLockingNeededForRelation(relation))
        return false;
 
    return true;                /* no excuse to skip predicate locking */
}

References InvalidSerializableXact, IsMVCCSnapshot, MySerializableXact, PredicateLockingNeededForRelation(), ReleasePredicateLocks(), and SxactIsROSafe.

Referenced by CheckForSerializableConflictOut(), CheckForSerializableConflictOutNeeded(), PredicateLockPage(), PredicateLockRelation(), and PredicateLockTID().

SerializationNeededForWrite()

static bool SerializationNeededForWrite ( Relation  relation )

inlinestatic

Definition at line 560 of file predicate.c.

{
    /* Nothing to do if this is not a serializable transaction */
    if (MySerializableXact == InvalidSerializableXact)
        return false;
 
    /* Check if the relation doesn't participate in predicate locking */
    if (!PredicateLockingNeededForRelation(relation))
        return false;
 
    return true;                /* no excuse to skip predicate locking */
}

References InvalidSerializableXact, MySerializableXact, and PredicateLockingNeededForRelation().

Referenced by CheckForSerializableConflictIn(), and CheckTableForSerializableConflictIn().

SerialPagePrecedesLogically()

static bool SerialPagePrecedesLogically ( int64  page1, int64  page2  )

static

Definition at line 731 of file predicate.c.

{
    TransactionId xid1;
    TransactionId xid2;
 
    xid1 = ((TransactionId) page1) * SERIAL_ENTRIESPERPAGE;
    xid1 += FirstNormalTransactionId + 1;
    xid2 = ((TransactionId) page2) * SERIAL_ENTRIESPERPAGE;
    xid2 += FirstNormalTransactionId + 1;
 
    return (TransactionIdPrecedes(xid1, xid2) &&
            TransactionIdPrecedes(xid1, xid2 + SERIAL_ENTRIESPERPAGE - 1));
}

References FirstNormalTransactionId, SERIAL_ENTRIESPERPAGE, and TransactionIdPrecedes().

Referenced by CheckPointPredicate(), SerialAdd(), and SerialInit().

SerialSetActiveSerXmin()

static void SerialSetActiveSerXmin ( TransactionId  xid )

static

Definition at line 985 of file predicate.c.

{