lwlock.h File Reference

#include "port/atomics.h"
#include "storage/lwlocknames.h"
#include "storage/proclist_types.h"

Include dependency graph for lwlock.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	LWLock
union	LWLockPadded
struct	NamedLWLockTranche

Macros
#define	LWLOCK_PADDED_SIZE   PG_CACHE_LINE_SIZE
#define	NUM_BUFFER_PARTITIONS   128
#define	LOG2_NUM_LOCK_PARTITIONS   4
#define	NUM_LOCK_PARTITIONS   (1 << LOG2_NUM_LOCK_PARTITIONS)
#define	LOG2_NUM_PREDICATELOCK_PARTITIONS   4
#define	NUM_PREDICATELOCK_PARTITIONS   (1 << LOG2_NUM_PREDICATELOCK_PARTITIONS)
#define	BUFFER_MAPPING_LWLOCK_OFFSET   NUM_INDIVIDUAL_LWLOCKS
#define	LOCK_MANAGER_LWLOCK_OFFSET    (BUFFER_MAPPING_LWLOCK_OFFSET + NUM_BUFFER_PARTITIONS)
#define	PREDICATELOCK_MANAGER_LWLOCK_OFFSET    (LOCK_MANAGER_LWLOCK_OFFSET + NUM_LOCK_PARTITIONS)
#define	NUM_FIXED_LWLOCKS    (PREDICATELOCK_MANAGER_LWLOCK_OFFSET + NUM_PREDICATELOCK_PARTITIONS)

Typedefs
typedef enum LWLockWaitState	LWLockWaitState
typedef struct LWLock	LWLock
typedef union LWLockPadded	LWLockPadded
typedef struct NamedLWLockTranche	NamedLWLockTranche
typedef enum LWLockMode	LWLockMode
typedef enum BuiltinTrancheIds	BuiltinTrancheIds
typedef LWLock *	LWLockId

Enumerations
enum	LWLockWaitState { LW_WS_NOT_WAITING , LW_WS_WAITING , LW_WS_PENDING_WAKEUP }
enum	LWLockMode { LW_EXCLUSIVE , LW_SHARED , LW_WAIT_UNTIL_FREE }
enum	BuiltinTrancheIds {   LWTRANCHE_XACT_BUFFER = NUM_INDIVIDUAL_LWLOCKS , LWTRANCHE_COMMITTS_BUFFER , LWTRANCHE_SUBTRANS_BUFFER , LWTRANCHE_MULTIXACTOFFSET_BUFFER ,   LWTRANCHE_MULTIXACTMEMBER_BUFFER , LWTRANCHE_NOTIFY_BUFFER , LWTRANCHE_SERIAL_BUFFER , LWTRANCHE_WAL_INSERT ,   LWTRANCHE_BUFFER_CONTENT , LWTRANCHE_REPLICATION_ORIGIN_STATE , LWTRANCHE_REPLICATION_SLOT_IO , LWTRANCHE_LOCK_FASTPATH ,   LWTRANCHE_BUFFER_MAPPING , LWTRANCHE_LOCK_MANAGER , LWTRANCHE_PREDICATE_LOCK_MANAGER , LWTRANCHE_PARALLEL_HASH_JOIN ,   LWTRANCHE_PARALLEL_QUERY_DSA , LWTRANCHE_PER_SESSION_DSA , LWTRANCHE_PER_SESSION_RECORD_TYPE , LWTRANCHE_PER_SESSION_RECORD_TYPMOD ,   LWTRANCHE_SHARED_TUPLESTORE , LWTRANCHE_SHARED_TIDBITMAP , LWTRANCHE_PARALLEL_APPEND , LWTRANCHE_PER_XACT_PREDICATE_LIST ,   LWTRANCHE_PGSTATS_DSA , LWTRANCHE_PGSTATS_HASH , LWTRANCHE_PGSTATS_DATA , LWTRANCHE_LAUNCHER_DSA ,   LWTRANCHE_LAUNCHER_HASH , LWTRANCHE_DSM_REGISTRY_DSA , LWTRANCHE_DSM_REGISTRY_HASH , LWTRANCHE_COMMITTS_SLRU ,   LWTRANCHE_MULTIXACTMEMBER_SLRU , LWTRANCHE_MULTIXACTOFFSET_SLRU , LWTRANCHE_NOTIFY_SLRU , LWTRANCHE_SERIAL_SLRU ,   LWTRANCHE_SUBTRANS_SLRU , LWTRANCHE_XACT_SLRU , LWTRANCHE_PARALLEL_VACUUM_DSA , LWTRANCHE_FIRST_USER_DEFINED }

Functions
	StaticAssertDecl (sizeof(LWLock)<=LWLOCK_PADDED_SIZE, "Miscalculated LWLock padding")
bool	LWLockAcquire (LWLock *lock, LWLockMode mode)
bool	LWLockConditionalAcquire (LWLock *lock, LWLockMode mode)
bool	LWLockAcquireOrWait (LWLock *lock, LWLockMode mode)
void	LWLockRelease (LWLock *lock)
void	LWLockReleaseClearVar (LWLock *lock, pg_atomic_uint64 *valptr, uint64 val)
void	LWLockReleaseAll (void)
bool	LWLockHeldByMe (LWLock *lock)
bool	LWLockAnyHeldByMe (LWLock *lock, int nlocks, size_t stride)
bool	LWLockHeldByMeInMode (LWLock *lock, LWLockMode mode)
bool	LWLockWaitForVar (LWLock *lock, pg_atomic_uint64 *valptr, uint64 oldval, uint64 *newval)
void	LWLockUpdateVar (LWLock *lock, pg_atomic_uint64 *valptr, uint64 val)
Size	LWLockShmemSize (void)
void	CreateLWLocks (void)
void	InitLWLockAccess (void)
const char *	GetLWLockIdentifier (uint32 classId, uint16 eventId)
void	RequestNamedLWLockTranche (const char *tranche_name, int num_lwlocks)
LWLockPadded *	GetNamedLWLockTranche (const char *tranche_name)
int	LWLockNewTrancheId (void)
void	LWLockRegisterTranche (int tranche_id, const char *tranche_name)
void	LWLockInitialize (LWLock *lock, int tranche_id)

Variables
PGDLLIMPORT LWLockPadded *	MainLWLockArray
PGDLLIMPORT NamedLWLockTranche *	NamedLWLockTrancheArray
PGDLLIMPORT int	NamedLWLockTrancheRequests

Macro Definition Documentation

BUFFER_MAPPING_LWLOCK_OFFSET

#define BUFFER_MAPPING_LWLOCK_OFFSET   NUM_INDIVIDUAL_LWLOCKS

Definition at line 104 of file lwlock.h.

LOCK_MANAGER_LWLOCK_OFFSET

#define LOCK_MANAGER_LWLOCK_OFFSET    (BUFFER_MAPPING_LWLOCK_OFFSET + NUM_BUFFER_PARTITIONS)

Definition at line 105 of file lwlock.h.

LOG2_NUM_LOCK_PARTITIONS

#define LOG2_NUM_LOCK_PARTITIONS   4

Definition at line 96 of file lwlock.h.

LOG2_NUM_PREDICATELOCK_PARTITIONS

#define LOG2_NUM_PREDICATELOCK_PARTITIONS   4

Definition at line 100 of file lwlock.h.

LWLOCK_PADDED_SIZE

#define LWLOCK_PADDED_SIZE   PG_CACHE_LINE_SIZE

Definition at line 62 of file lwlock.h.

NUM_BUFFER_PARTITIONS

#define NUM_BUFFER_PARTITIONS   128

Definition at line 93 of file lwlock.h.

NUM_FIXED_LWLOCKS

#define NUM_FIXED_LWLOCKS    (PREDICATELOCK_MANAGER_LWLOCK_OFFSET + NUM_PREDICATELOCK_PARTITIONS)

Definition at line 109 of file lwlock.h.

NUM_LOCK_PARTITIONS

#define NUM_LOCK_PARTITIONS   (1 << LOG2_NUM_LOCK_PARTITIONS)

Definition at line 97 of file lwlock.h.

NUM_PREDICATELOCK_PARTITIONS

#define NUM_PREDICATELOCK_PARTITIONS   (1 << LOG2_NUM_PREDICATELOCK_PARTITIONS)

Definition at line 101 of file lwlock.h.

PREDICATELOCK_MANAGER_LWLOCK_OFFSET

#define PREDICATELOCK_MANAGER_LWLOCK_OFFSET    (LOCK_MANAGER_LWLOCK_OFFSET + NUM_LOCK_PARTITIONS)

Definition at line 107 of file lwlock.h.

Typedef Documentation

BuiltinTrancheIds

typedef enum BuiltinTrancheIds BuiltinTrancheIds

LWLock

typedef struct LWLock LWLock

LWLockId

typedef LWLock* LWLockId

Definition at line 226 of file lwlock.h.

LWLockMode

typedef enum LWLockMode LWLockMode

LWLockPadded

typedef union LWLockPadded LWLockPadded

LWLockWaitState

typedef enum LWLockWaitState LWLockWaitState

NamedLWLockTranche

typedef struct NamedLWLockTranche NamedLWLockTranche

Enumeration Type Documentation

BuiltinTrancheIds

enum BuiltinTrancheIds

Enumerator
LWTRANCHE_XACT_BUFFER
LWTRANCHE_COMMITTS_BUFFER
LWTRANCHE_SUBTRANS_BUFFER
LWTRANCHE_MULTIXACTOFFSET_BUFFER
LWTRANCHE_MULTIXACTMEMBER_BUFFER
LWTRANCHE_NOTIFY_BUFFER
LWTRANCHE_SERIAL_BUFFER
LWTRANCHE_WAL_INSERT
LWTRANCHE_BUFFER_CONTENT
LWTRANCHE_REPLICATION_ORIGIN_STATE
LWTRANCHE_REPLICATION_SLOT_IO
LWTRANCHE_LOCK_FASTPATH
LWTRANCHE_BUFFER_MAPPING
LWTRANCHE_LOCK_MANAGER
LWTRANCHE_PREDICATE_LOCK_MANAGER
LWTRANCHE_PARALLEL_HASH_JOIN
LWTRANCHE_PARALLEL_QUERY_DSA
LWTRANCHE_PER_SESSION_DSA
LWTRANCHE_PER_SESSION_RECORD_TYPE
LWTRANCHE_PER_SESSION_RECORD_TYPMOD
LWTRANCHE_SHARED_TUPLESTORE
LWTRANCHE_SHARED_TIDBITMAP
LWTRANCHE_PARALLEL_APPEND
LWTRANCHE_PER_XACT_PREDICATE_LIST
LWTRANCHE_PGSTATS_DSA
LWTRANCHE_PGSTATS_HASH
LWTRANCHE_PGSTATS_DATA
LWTRANCHE_LAUNCHER_DSA
LWTRANCHE_LAUNCHER_HASH
LWTRANCHE_DSM_REGISTRY_DSA
LWTRANCHE_DSM_REGISTRY_HASH
LWTRANCHE_COMMITTS_SLRU
LWTRANCHE_MULTIXACTMEMBER_SLRU
LWTRANCHE_MULTIXACTOFFSET_SLRU
LWTRANCHE_NOTIFY_SLRU
LWTRANCHE_SERIAL_SLRU
LWTRANCHE_SUBTRANS_SLRU
LWTRANCHE_XACT_SLRU
LWTRANCHE_PARALLEL_VACUUM_DSA
LWTRANCHE_FIRST_USER_DEFINED

Definition at line 177 of file lwlock.h.

{
    LWTRANCHE_XACT_BUFFER = NUM_INDIVIDUAL_LWLOCKS,
    LWTRANCHE_COMMITTS_BUFFER,
    LWTRANCHE_SUBTRANS_BUFFER,
    LWTRANCHE_MULTIXACTOFFSET_BUFFER,
    LWTRANCHE_MULTIXACTMEMBER_BUFFER,
    LWTRANCHE_NOTIFY_BUFFER,
    LWTRANCHE_SERIAL_BUFFER,
    LWTRANCHE_WAL_INSERT,
    LWTRANCHE_BUFFER_CONTENT,
    LWTRANCHE_REPLICATION_ORIGIN_STATE,
    LWTRANCHE_REPLICATION_SLOT_IO,
    LWTRANCHE_LOCK_FASTPATH,
    LWTRANCHE_BUFFER_MAPPING,
    LWTRANCHE_LOCK_MANAGER,
    LWTRANCHE_PREDICATE_LOCK_MANAGER,
    LWTRANCHE_PARALLEL_HASH_JOIN,
    LWTRANCHE_PARALLEL_QUERY_DSA,
    LWTRANCHE_PER_SESSION_DSA,
    LWTRANCHE_PER_SESSION_RECORD_TYPE,
    LWTRANCHE_PER_SESSION_RECORD_TYPMOD,
    LWTRANCHE_SHARED_TUPLESTORE,
    LWTRANCHE_SHARED_TIDBITMAP,
    LWTRANCHE_PARALLEL_APPEND,
    LWTRANCHE_PER_XACT_PREDICATE_LIST,
    LWTRANCHE_PGSTATS_DSA,
    LWTRANCHE_PGSTATS_HASH,
    LWTRANCHE_PGSTATS_DATA,
    LWTRANCHE_LAUNCHER_DSA,
    LWTRANCHE_LAUNCHER_HASH,
    LWTRANCHE_DSM_REGISTRY_DSA,
    LWTRANCHE_DSM_REGISTRY_HASH,
    LWTRANCHE_COMMITTS_SLRU,
    LWTRANCHE_MULTIXACTMEMBER_SLRU,
    LWTRANCHE_MULTIXACTOFFSET_SLRU,
    LWTRANCHE_NOTIFY_SLRU,
    LWTRANCHE_SERIAL_SLRU,
    LWTRANCHE_SUBTRANS_SLRU,
    LWTRANCHE_XACT_SLRU,
    LWTRANCHE_PARALLEL_VACUUM_DSA,
    LWTRANCHE_FIRST_USER_DEFINED,
}           BuiltinTrancheIds;

LWLockMode

enum LWLockMode

Enumerator
LW_EXCLUSIVE
LW_SHARED
LW_WAIT_UNTIL_FREE

Definition at line 112 of file lwlock.h.

{
    LW_EXCLUSIVE,
    LW_SHARED,
    LW_WAIT_UNTIL_FREE,         /* A special mode used in PGPROC->lwWaitMode,
                                 * when waiting for lock to become free. Not
                                 * to be used as LWLockAcquire argument */
} LWLockMode;

LWLockWaitState

enum LWLockWaitState

Enumerator
LW_WS_NOT_WAITING
LW_WS_WAITING
LW_WS_PENDING_WAKEUP

Definition at line 28 of file lwlock.h.

{
    LW_WS_NOT_WAITING,          /* not currently waiting / woken up */
    LW_WS_WAITING,              /* currently waiting */
    LW_WS_PENDING_WAKEUP,       /* removed from waitlist, but not yet
                                 * signalled */
}           LWLockWaitState;

Function Documentation

CreateLWLocks()

void CreateLWLocks

(

void

)

Definition at line 453 of file lwlock.c.

{
    if (!IsUnderPostmaster)
    {
        Size        spaceLocks = LWLockShmemSize();
        int        *LWLockCounter;
        char       *ptr;
 
        /* Allocate space */
        ptr = (char *) ShmemAlloc(spaceLocks);
 
        /* Leave room for dynamic allocation of tranches */
        ptr += sizeof(int);
 
        /* Ensure desired alignment of LWLock array */
        ptr += LWLOCK_PADDED_SIZE - ((uintptr_t) ptr) % LWLOCK_PADDED_SIZE;
 
        MainLWLockArray = (LWLockPadded *) ptr;
 
        /*
         * Initialize the dynamic-allocation counter for tranches, which is
         * stored just before the first LWLock.
         */
        LWLockCounter = (int *) ((char *) MainLWLockArray - sizeof(int));
        *LWLockCounter = LWTRANCHE_FIRST_USER_DEFINED;
 
        /* Initialize all LWLocks */
        InitializeLWLocks();
    }
 
    /* Register named extension LWLock tranches in the current process. */
    for (int i = 0; i < NamedLWLockTrancheRequests; i++)
        LWLockRegisterTranche(NamedLWLockTrancheArray[i].trancheId,
                              NamedLWLockTrancheArray[i].trancheName);
}

References i, InitializeLWLocks(), IsUnderPostmaster, LWLOCK_PADDED_SIZE, LWLockRegisterTranche(), LWLockShmemSize(), LWTRANCHE_FIRST_USER_DEFINED, MainLWLockArray, NamedLWLockTrancheArray, NamedLWLockTrancheRequests, and ShmemAlloc().

Referenced by CreateOrAttachShmemStructs().

GetLWLockIdentifier()

const char* GetLWLockIdentifier	(	uint32	classId,
		uint16	eventId
	)

Definition at line 769 of file lwlock.c.

{
    Assert(classId == PG_WAIT_LWLOCK);
    /* The event IDs are just tranche numbers. */
    return GetLWTrancheName(eventId);
}

References Assert, GetLWTrancheName(), and PG_WAIT_LWLOCK.

Referenced by pgstat_get_wait_event().

GetNamedLWLockTranche()

LWLockPadded* GetNamedLWLockTranche

(

const char *

tranche_name

)

Definition at line 576 of file lwlock.c.

{
    int         lock_pos;
    int         i;
 
    /*
     * Obtain the position of base address of LWLock belonging to requested
     * tranche_name in MainLWLockArray.  LWLocks for named tranches are placed
     * in MainLWLockArray after fixed locks.
     */
    lock_pos = NUM_FIXED_LWLOCKS;
    for (i = 0; i < NamedLWLockTrancheRequests; i++)
    {
        if (strcmp(NamedLWLockTrancheRequestArray[i].tranche_name,
                   tranche_name) == 0)
            return &MainLWLockArray[lock_pos];
 
        lock_pos += NamedLWLockTrancheRequestArray[i].num_lwlocks;
    }
 
    elog(ERROR, "requested tranche is not registered");
 
    /* just to keep compiler quiet */
    return NULL;
}

References elog, ERROR, i, MainLWLockArray, NamedLWLockTrancheRequestArray, NamedLWLockTrancheRequests, NUM_FIXED_LWLOCKS, and NamedLWLockTrancheRequest::num_lwlocks.

Referenced by pgss_shmem_startup().

InitLWLockAccess()

void InitLWLockAccess

(

void

)

Definition at line 560 of file lwlock.c.

{
#ifdef LWLOCK_STATS
    init_lwlock_stats();
#endif
}

Referenced by InitAuxiliaryProcess(), and InitProcess().

LWLockAcquire()

bool LWLockAcquire	(	LWLock *	lock,
		LWLockMode	mode
	)

Definition at line 1170 of file lwlock.c.

{
    PGPROC     *proc = MyProc;
    bool        result = true;
    int         extraWaits = 0;
#ifdef LWLOCK_STATS
    lwlock_stats *lwstats;
 
    lwstats = get_lwlock_stats_entry(lock);
#endif
 
    Assert(mode == LW_SHARED || mode == LW_EXCLUSIVE);
 
    PRINT_LWDEBUG("LWLockAcquire", lock, mode);
 
#ifdef LWLOCK_STATS
    /* Count lock acquisition attempts */
    if (mode == LW_EXCLUSIVE)
        lwstats->ex_acquire_count++;
    else
        lwstats->sh_acquire_count++;
#endif                          /* LWLOCK_STATS */
 
    /*
     * We can't wait if we haven't got a PGPROC.  This should only occur
     * during bootstrap or shared memory initialization.  Put an Assert here
     * to catch unsafe coding practices.
     */
    Assert(!(proc == NULL && IsUnderPostmaster));
 
    /* Ensure we will have room to remember the lock */
    if (num_held_lwlocks >= MAX_SIMUL_LWLOCKS)
        elog(ERROR, "too many LWLocks taken");
 
    /*
     * Lock out cancel/die interrupts until we exit the code section protected
     * by the LWLock.  This ensures that interrupts will not interfere with
     * manipulations of data structures in shared memory.
     */
    HOLD_INTERRUPTS();
 
    /*
     * Loop here to try to acquire lock after each time we are signaled by
     * LWLockRelease.
     *
     * NOTE: it might seem better to have LWLockRelease actually grant us the
     * lock, rather than retrying and possibly having to go back to sleep. But
     * in practice that is no good because it means a process swap for every
     * lock acquisition when two or more processes are contending for the same
     * lock.  Since LWLocks are normally used to protect not-very-long
     * sections of computation, a process needs to be able to acquire and
     * release the same lock many times during a single CPU time slice, even
     * in the presence of contention.  The efficiency of being able to do that
     * outweighs the inefficiency of sometimes wasting a process dispatch
     * cycle because the lock is not free when a released waiter finally gets
     * to run.  See pgsql-hackers archives for 29-Dec-01.
     */
    for (;;)
    {
        bool        mustwait;
 
        /*
         * Try to grab the lock the first time, we're not in the waitqueue
         * yet/anymore.
         */
        mustwait = LWLockAttemptLock(lock, mode);
 
        if (!mustwait)
        {
            LOG_LWDEBUG("LWLockAcquire", lock, "immediately acquired lock");
            break;              /* got the lock */
        }
 
        /*
         * Ok, at this point we couldn't grab the lock on the first try. We
         * cannot simply queue ourselves to the end of the list and wait to be
         * woken up because by now the lock could long have been released.
         * Instead add us to the queue and try to grab the lock again. If we
         * succeed we need to revert the queuing and be happy, otherwise we
         * recheck the lock. If we still couldn't grab it, we know that the
         * other locker will see our queue entries when releasing since they
         * existed before we checked for the lock.
         */
 
        /* add to the queue */
        LWLockQueueSelf(lock, mode);
 
        /* we're now guaranteed to be woken up if necessary */
        mustwait = LWLockAttemptLock(lock, mode);
 
        /* ok, grabbed the lock the second time round, need to undo queueing */
        if (!mustwait)
        {
            LOG_LWDEBUG("LWLockAcquire", lock, "acquired, undoing queue");
 
            LWLockDequeueSelf(lock);
            break;
        }
 
        /*
         * Wait until awakened.
         *
         * It is possible that we get awakened for a reason other than being
         * signaled by LWLockRelease.  If so, loop back and wait again.  Once
         * we've gotten the LWLock, re-increment the sema by the number of
         * additional signals received.
         */
        LOG_LWDEBUG("LWLockAcquire", lock, "waiting");
 
#ifdef LWLOCK_STATS
        lwstats->block_count++;
#endif
 
        LWLockReportWaitStart(lock);
        if (TRACE_POSTGRESQL_LWLOCK_WAIT_START_ENABLED())
            TRACE_POSTGRESQL_LWLOCK_WAIT_START(T_NAME(lock), mode);
 
        for (;;)
        {
            PGSemaphoreLock(proc->sem);
            if (proc->lwWaiting == LW_WS_NOT_WAITING)
                break;
            extraWaits++;
        }
 
        /* Retrying, allow LWLockRelease to release waiters again. */
        pg_atomic_fetch_or_u32(&lock->state, LW_FLAG_RELEASE_OK);
 
#ifdef LOCK_DEBUG
        {
            /* not waiting anymore */
            uint32      nwaiters PG_USED_FOR_ASSERTS_ONLY = pg_atomic_fetch_sub_u32(&lock->nwaiters, 1);
 
            Assert(nwaiters < MAX_BACKENDS);
        }
#endif
 
        if (TRACE_POSTGRESQL_LWLOCK_WAIT_DONE_ENABLED())
            TRACE_POSTGRESQL_LWLOCK_WAIT_DONE(T_NAME(lock), mode);
        LWLockReportWaitEnd();
 
        LOG_LWDEBUG("LWLockAcquire", lock, "awakened");
 
        /* Now loop back and try to acquire lock again. */
        result = false;
    }
 
    if (TRACE_POSTGRESQL_LWLOCK_ACQUIRE_ENABLED())
        TRACE_POSTGRESQL_LWLOCK_ACQUIRE(T_NAME(lock), mode);
 
    /* Add lock to list of locks held by this backend */
    held_lwlocks[num_held_lwlocks].lock = lock;
    held_lwlocks[num_held_lwlocks++].mode = mode;
 
    /*
     * Fix the process wait semaphore's count for any absorbed wakeups.
     */
    while (extraWaits-- > 0)
        PGSemaphoreUnlock(proc->sem);
 
    return result;
}

References Assert, elog, ERROR, held_lwlocks, HOLD_INTERRUPTS, IsUnderPostmaster, LWLockHandle::lock, LOG_LWDEBUG, LW_EXCLUSIVE, LW_FLAG_RELEASE_OK, LW_SHARED, LW_WS_NOT_WAITING, LWLockAttemptLock(), LWLockDequeueSelf(), LWLockQueueSelf(), LWLockReportWaitEnd(), LWLockReportWaitStart(), PGPROC::lwWaiting, MAX_BACKENDS, MAX_SIMUL_LWLOCKS, LWLockHandle::mode, mode, MyProc, num_held_lwlocks, pg_atomic_fetch_or_u32(), pg_atomic_fetch_sub_u32(), PG_USED_FOR_ASSERTS_ONLY, PGSemaphoreLock(), PGSemaphoreUnlock(), PRINT_LWDEBUG, PGPROC::sem, LWLock::state, and T_NAME.

Referenced by _bt_end_vacuum(), _bt_start_vacuum(), _bt_vacuum_cycleid(), AbsorbSyncRequests(), ActivateCommitTs(), AdjustToFullTransactionId(), AdvanceNextFullTransactionIdPastXid(), AdvanceOldestClogXid(), AdvanceOldestCommitTsXid(), AdvanceXLInsertBuffer(), alloc_object(), AlterSystemSetConfigFile(), ApplyLauncherMain(), apw_detach_shmem(), apw_dump_now(), apw_load_buffers(), asyncQueueAddEntries(), asyncQueueAdvanceTail(), asyncQueueReadAllNotifications(), asyncQueueUnregister(), AtAbort_Twophase(), AtEOXact_LogicalRepWorkers(), AtPrepare_PredicateLocks(), attach_internal(), autoprewarm_main(), autoprewarm_start_worker(), AutoVacuumRequestWork(), AutoVacWorkerMain(), BackendPidGetProc(), BackendXidGetPid(), BecomeLockGroupLeader(), BecomeLockGroupMember(), BootStrapCLOG(), BootStrapMultiXact(), BootStrapSUBTRANS(), BufferAlloc(), CancelDBBackends(), check_for_freed_segments(), CheckDeadLock(), CheckForSerializableConflictOut(), CheckPointPredicate(), CheckPointRelationMap(), CheckPointReplicationOrigin(), CheckPointReplicationSlots(), CheckPointTwoPhase(), CheckTableForSerializableConflictIn(), CheckTargetForConflictsIn(), choose_next_subplan_for_leader(), choose_next_subplan_for_worker(), CleanupInvalidationState(), ClearOldPredicateLocks(), clog_redo(), commit_ts_redo(), ComputeXidHorizons(), consume_xids_shortcut(), copy_replication_slot(), CountDBBackends(), CountDBConnections(), CountOtherDBBackends(), CountUserBackends(), CreateCheckPoint(), CreateEndOfRecoveryRecord(), CreateInitDecodingContext(), CreatePredicateLock(), CreateRestartPoint(), DeactivateCommitTs(), DeleteChildTargetLocks(), DeleteLockTarget(), destroy_superblock(), do_autovacuum(), do_pg_backup_start(), do_pg_backup_stop(), do_start_worker(), DropAllPredicateLocksFromTable(), DropSubscription(), DropTableSpace(), dsa_allocate_extended(), dsa_dump(), dsa_free(), dsa_get_total_size(), dsa_pin(), dsa_release_in_place(), dsa_set_size_limit(), dsa_trim(), dsa_unpin(), dshash_delete_key(), dshash_dump(), dshash_find(), dshash_find_or_insert(), dshash_seq_next(), dsm_attach(), dsm_create(), dsm_detach(), dsm_pin_segment(), dsm_unpin_segment(), ensure_active_superblock(), entry_reset(), EvictUnpinnedBuffer(), Exec_ListenPreCommit(), ExecParallelHashMergeCounters(), ExecParallelHashPopChunkQueue(), ExecParallelHashTupleAlloc(), ExecParallelHashTuplePrealloc(), ExpireAllKnownAssignedTransactionIds(), ExpireOldKnownAssignedTransactionIds(), ExpireTreeKnownAssignedTransactionIds(), ExtendBufferedRelShared(), ExtendCLOG(), ExtendCommitTs(), ExtendMultiXactMember(), ExtendMultiXactOffset(), ExtendSUBTRANS(), FastPathGetRelationLockEntry(), FastPathTransferRelationLocks(), FindAndDropRelationBuffers(), FinishPreparedTransaction(), FlushDatabaseBuffers(), FlushRelationBuffers(), FlushRelationsAllBuffers(), ForceTransactionIdLimitUpdate(), ForwardSyncRequest(), FreeWorkerInfo(), get_local_synced_slots(), get_val_in_shmem(), GetBackgroundWorkerPid(), GetBackgroundWorkerTypeByPid(), GetBlockerStatusData(), GetConflictingVirtualXIDs(), GetCurrentVirtualXIDs(), GetLastImportantRecPtr(), GetLastSegSwitchData(), GetLatestCommitTsData(), GetLeaderApplyWorkerPid(), GetLockConflicts(), GetLockStatusData(), GetMultiXactIdMembers(), GetNewMultiXactId(), GetNewObjectId(), GetNewTransactionId(), GetOldestActiveTransactionId(), GetOldestMultiXactId(), GetOldestRestartPoint(), GetOldestSafeDecodingTransactionId(), GetOldestUnsummarizedLSN(), GetPredicateLockStatusData(), GetPreparedTransactionList(), GetRunningTransactionData(), GetRunningTransactionLocks(), GetSafeSnapshot(), GetSafeSnapshotBlockingPids(), GetSerializableTransactionSnapshotInt(), GetSnapshotData(), GetVirtualXIDsDelayingChkpt(), GetWaitEventExtensionIdentifier(), GetWaitEventExtensionNames(), GetWalSummarizerState(), HaveVirtualXIDsDelayingChkpt(), init_dsm_registry(), InjectionPointAttach(), InjectionPointDetach(), InjectionPointRun(), InstallXLogFileSegment(), InvalidateBuffer(), InvalidateObsoleteReplicationSlots(), InvalidatePossiblyObsoleteSlot(), InvalidateVictimBuffer(), IsInstallXLogFileSegmentActive(), KnownAssignedXidsCompress(), KnownAssignedXidsReset(), lock_twophase_recover(), LockAcquireExtended(), LockBuffer(), LockErrorCleanup(), LockGXact(), LockHasWaiters(), LockRefindAndRelease(), LockRelease(), LockReleaseAll(), LockWaiterCount(), logicalrep_launcher_attach_dshmem(), logicalrep_pa_worker_stop(), logicalrep_worker_attach(), logicalrep_worker_detach(), logicalrep_worker_launch(), logicalrep_worker_stop(), logicalrep_worker_stop_internal(), logicalrep_worker_wakeup(), LookupGXact(), MarkAsPrepared(), MarkAsPreparing(), MaybeExtendOffsetSlru(), multixact_redo(), MultiXactAdvanceNextMXact(), MultiXactGetCheckptMulti(), MultiXactIdSetOldestMember(), MultiXactIdSetOldestVisible(), MultiXactSetNextMXact(), PageIsPredicateLocked(), perform_relmap_update(), pg_control_checkpoint(), pg_control_init(), pg_control_recovery(), pg_control_system(), pg_get_replication_slots(), pg_get_shmem_allocations(), pg_notification_queue_usage(), pg_show_replication_origin_status(), pg_stat_get_subscription(), pg_stat_statements_internal(), pg_xact_status(), pgss_shmem_startup(), pgss_store(), pgstat_archiver_reset_all_cb(), pgstat_archiver_snapshot_cb(), pgstat_bgwriter_reset_all_cb(), pgstat_bgwriter_snapshot_cb(), pgstat_build_snapshot(), pgstat_checkpointer_reset_all_cb(), pgstat_checkpointer_snapshot_cb(), pgstat_fetch_replslot(), pgstat_flush_io(), pgstat_flush_wal(), pgstat_io_reset_all_cb(), pgstat_io_snapshot_cb(), pgstat_lock_entry(), pgstat_lock_entry_shared(), pgstat_reset_matching_entries(), pgstat_reset_replslot(), pgstat_reset_slru_counter_internal(), pgstat_slru_flush(), pgstat_slru_snapshot_cb(), pgstat_wal_reset_all_cb(), pgstat_wal_snapshot_cb(), PostPrepare_Locks(), PostPrepare_MultiXact(), PostPrepare_Twophase(), PreCommit_CheckForSerializationFailure(), PreCommit_Notify(), predicatelock_twophase_recover(), PredicateLockPageSplit(), PredicateLockTwoPhaseFinish(), PrefetchSharedBuffer(), PrescanPreparedTransactions(), ProcArrayAdd(), ProcArrayApplyRecoveryInfo(), ProcArrayApplyXidAssignment(), ProcArrayClearTransaction(), ProcArrayEndTransaction(), ProcArrayGetReplicationSlotXmin(), ProcArrayGroupClearXid(), ProcArrayInstallImportedXmin(), ProcArrayInstallRestoredXmin(), ProcArrayRemove(), ProcArraySetReplicationSlotXmin(), process_syncing_tables_for_apply(), ProcKill(), ProcNumberGetTransactionIds(), ProcSleep(), ReachedEndOfBackup(), read_relmap_file(), ReadMultiXactCounts(), ReadMultiXactIdRange(), ReadNextFullTransactionId(), ReadNextMultiXactId(), ReadReplicationSlot(), RecordNewMultiXact(), RecoverPreparedTransactions(), RegisterDynamicBackgroundWorker(), RegisterPredicateLockingXid(), RelationCacheInitFilePreInvalidate(), RelationMapCopy(), RelationMapFinishBootstrap(), ReleaseOneSerializableXact(), ReleasePredicateLocks(), relmap_redo(), RemoveScratchTarget(), ReplicationOriginExitCleanup(), ReplicationSlotAcquire(), ReplicationSlotCleanup(), ReplicationSlotCreate(), ReplicationSlotDropPtr(), ReplicationSlotName(), ReplicationSlotRelease(), ReplicationSlotsComputeLogicalRestartLSN(), ReplicationSlotsComputeRequiredLSN(), ReplicationSlotsComputeRequiredXmin(), ReplicationSlotsCountDBSlots(), ReplicationSlotsDropDBSlots(), replorigin_advance(), replorigin_get_progress(), replorigin_session_advance(), replorigin_session_get_progress(), replorigin_session_reset(), replorigin_session_setup(), replorigin_state_clear(), resize(), RestoreScratchTarget(), restoreTwoPhaseData(), SaveSlotToPath(), SearchNamedReplicationSlot(), SerialAdd(), SerialGetMinConflictCommitSeqNo(), SerialInit(), SerialSetActiveSerXmin(), set_indexsafe_procflags(), set_val_in_shmem(), SetCommitTsLimit(), SetInstallXLogFileSegmentActive(), SetMultiXactIdLimit(), SetNextObjectId(), SetOffsetVacuumLimit(), SetTransactionIdLimit(), SetWalSummarizerLatch(), SetXidCommitTsInPage(), SharedInvalBackendInit(), ShmemInitStruct(), SICleanupQueue(), SIGetDataEntries(), SignalBackends(), SignalVirtualTransaction(), SIInsertDataEntries(), SimpleLruReadPage(), SimpleLruReadPage_ReadOnly(), SimpleLruTruncate(), SimpleLruWaitIO(), SimpleLruWriteAll(), SlruDeleteSegment(), SlruInternalWritePage(), SnapBuildInitialSnapshot(), ss_get_location(), StandbyRecoverPreparedTransactions(), StandbySlotsHaveCaughtup(), StartupDecodingContext(), StartupSUBTRANS(), StartupXLOG(), sts_parallel_scan_next(), SubTransSetParent(), SummarizeOldestCommittedSxact(), SummarizeWAL(), SwitchIntoArchiveRecovery(), synchronize_one_slot(), SyncOneBuffer(), SyncRepCancelWait(), SyncRepCleanupAtProcExit(), SyncRepReleaseWaiters(), SyncRepUpdateSyncStandbysDefined(), SyncRepWaitForLSN(), TablespaceCreateDbspace(), tbm_shared_iterate(), TerminateBackgroundWorker(), TerminateOtherDBBackends(), test_slru_page_exists(), test_slru_page_read(), test_slru_page_write(), TransactionGroupUpdateXidStatus(), TransactionIdGetCommitTsData(), TransactionIdIsActive(), TransactionIdIsInProgress(), TransactionIdSetPageStatus(), TransactionTreeSetCommitTsData(), TransferPredicateLocksToNewTarget(), TrimCLOG(), TrimMultiXact(), TruncateMultiXact(), TwoPhaseGetGXact(), TwoPhaseGetXidByVirtualXID(), update_cached_xid_range(), update_synced_slots_inactive_since(), UpdateMinRecoveryPoint(), vac_truncate_clog(), vacuum_rel(), VacuumUpdateCosts(), validate_standby_slots(), VirtualXactLock(), VirtualXactLockTableCleanup(), VirtualXactLockTableInsert(), wait_for_relation_state_change(), wait_for_worker_state_change(), WaitEventExtensionNew(), WaitForReplicationWorkerAttach(), WaitForWalSummarization(), WALInsertLockAcquire(), WALInsertLockAcquireExclusive(), WalSummarizerMain(), WalSummarizerShutdown(), write_relcache_init_file(), xact_redo(), XidCacheRemoveRunningXids(), xlog_redo(), XLogBackgroundFlush(), XLogReportParameters(), and XLogShutdownWalRcv().

LWLockAcquireOrWait()

bool LWLockAcquireOrWait	(	LWLock *	lock,
		LWLockMode	mode
	)

Definition at line 1398 of file lwlock.c.

{
    PGPROC     *proc = MyProc;
    bool        mustwait;
    int         extraWaits = 0;
#ifdef LWLOCK_STATS
    lwlock_stats *lwstats;
 
    lwstats = get_lwlock_stats_entry(lock);
#endif
 
    Assert(mode == LW_SHARED || mode == LW_EXCLUSIVE);
 
    PRINT_LWDEBUG("LWLockAcquireOrWait", lock, mode);
 
    /* Ensure we will have room to remember the lock */
    if (num_held_lwlocks >= MAX_SIMUL_LWLOCKS)
        elog(ERROR, "too many LWLocks taken");
 
    /*
     * Lock out cancel/die interrupts until we exit the code section protected
     * by the LWLock.  This ensures that interrupts will not interfere with
     * manipulations of data structures in shared memory.
     */
    HOLD_INTERRUPTS();
 
    /*
     * NB: We're using nearly the same twice-in-a-row lock acquisition
     * protocol as LWLockAcquire(). Check its comments for details.
     */
    mustwait = LWLockAttemptLock(lock, mode);
 
    if (mustwait)
    {
        LWLockQueueSelf(lock, LW_WAIT_UNTIL_FREE);
 
        mustwait = LWLockAttemptLock(lock, mode);
 
        if (mustwait)
        {
            /*
             * Wait until awakened.  Like in LWLockAcquire, be prepared for
             * bogus wakeups.
             */
            LOG_LWDEBUG("LWLockAcquireOrWait", lock, "waiting");
 
#ifdef LWLOCK_STATS
            lwstats->block_count++;
#endif
 
            LWLockReportWaitStart(lock);
            if (TRACE_POSTGRESQL_LWLOCK_WAIT_START_ENABLED())
                TRACE_POSTGRESQL_LWLOCK_WAIT_START(T_NAME(lock), mode);
 
            for (;;)
            {
                PGSemaphoreLock(proc->sem);
                if (proc->lwWaiting == LW_WS_NOT_WAITING)
                    break;
                extraWaits++;
            }
 
#ifdef LOCK_DEBUG
            {
                /* not waiting anymore */
                uint32      nwaiters PG_USED_FOR_ASSERTS_ONLY = pg_atomic_fetch_sub_u32(&lock->nwaiters, 1);
 
                Assert(nwaiters < MAX_BACKENDS);
            }
#endif
            if (TRACE_POSTGRESQL_LWLOCK_WAIT_DONE_ENABLED())
                TRACE_POSTGRESQL_LWLOCK_WAIT_DONE(T_NAME(lock), mode);
            LWLockReportWaitEnd();
 
            LOG_LWDEBUG("LWLockAcquireOrWait", lock, "awakened");
        }
        else
        {
            LOG_LWDEBUG("LWLockAcquireOrWait", lock, "acquired, undoing queue");
 
            /*
             * Got lock in the second attempt, undo queueing. We need to treat
             * this as having successfully acquired the lock, otherwise we'd
             * not necessarily wake up people we've prevented from acquiring
             * the lock.
             */
            LWLockDequeueSelf(lock);
        }
    }
 
    /*
     * Fix the process wait semaphore's count for any absorbed wakeups.
     */
    while (extraWaits-- > 0)
        PGSemaphoreUnlock(proc->sem);
 
    if (mustwait)
    {
        /* Failed to get lock, so release interrupt holdoff */
        RESUME_INTERRUPTS();
        LOG_LWDEBUG("LWLockAcquireOrWait", lock, "failed");
        if (TRACE_POSTGRESQL_LWLOCK_ACQUIRE_OR_WAIT_FAIL_ENABLED())
            TRACE_POSTGRESQL_LWLOCK_ACQUIRE_OR_WAIT_FAIL(T_NAME(lock), mode);
    }
    else
    {
        LOG_LWDEBUG("LWLockAcquireOrWait", lock, "succeeded");
        /* Add lock to list of locks held by this backend */
        held_lwlocks[num_held_lwlocks].lock = lock;
        held_lwlocks[num_held_lwlocks++].mode = mode;
        if (TRACE_POSTGRESQL_LWLOCK_ACQUIRE_OR_WAIT_ENABLED())
            TRACE_POSTGRESQL_LWLOCK_ACQUIRE_OR_WAIT(T_NAME(lock), mode);
    }
 
    return !mustwait;
}

References Assert, elog, ERROR, held_lwlocks, HOLD_INTERRUPTS, LWLockHandle::lock, LOG_LWDEBUG, LW_EXCLUSIVE, LW_SHARED, LW_WAIT_UNTIL_FREE, LW_WS_NOT_WAITING, LWLockAttemptLock(), LWLockDequeueSelf(), LWLockQueueSelf(), LWLockReportWaitEnd(), LWLockReportWaitStart(), PGPROC::lwWaiting, MAX_BACKENDS, MAX_SIMUL_LWLOCKS, LWLockHandle::mode, mode, MyProc, num_held_lwlocks, pg_atomic_fetch_sub_u32(), PG_USED_FOR_ASSERTS_ONLY, PGSemaphoreLock(), PGSemaphoreUnlock(), PRINT_LWDEBUG, RESUME_INTERRUPTS, PGPROC::sem, and T_NAME.

Referenced by XLogFlush().

LWLockAnyHeldByMe()

bool LWLockAnyHeldByMe	(	LWLock *	lock,
		int	nlocks,
		size_t	stride
	)

Definition at line 1913 of file lwlock.c.

{
    char       *held_lock_addr;
    char       *begin;
    char       *end;
    int         i;
 
    begin = (char *) lock;
    end = begin + nlocks * stride;
    for (i = 0; i < num_held_lwlocks; i++)
    {
        held_lock_addr = (char *) held_lwlocks[i].lock;
        if (held_lock_addr >= begin &&
            held_lock_addr < end &&
            (held_lock_addr - begin) % stride == 0)
            return true;
    }
    return false;
}

References held_lwlocks, i, and num_held_lwlocks.

LWLockConditionalAcquire()

bool LWLockConditionalAcquire	(	LWLock *	lock,
		LWLockMode	mode
	)

Definition at line 1341 of file lwlock.c.

{
    bool        mustwait;
 
    Assert(mode == LW_SHARED || mode == LW_EXCLUSIVE);
 
    PRINT_LWDEBUG("LWLockConditionalAcquire", lock, mode);
 
    /* Ensure we will have room to remember the lock */
    if (num_held_lwlocks >= MAX_SIMUL_LWLOCKS)
        elog(ERROR, "too many LWLocks taken");
 
    /*
     * Lock out cancel/die interrupts until we exit the code section protected
     * by the LWLock.  This ensures that interrupts will not interfere with
     * manipulations of data structures in shared memory.
     */
    HOLD_INTERRUPTS();
 
    /* Check for the lock */
    mustwait = LWLockAttemptLock(lock, mode);
 
    if (mustwait)
    {
        /* Failed to get lock, so release interrupt holdoff */
        RESUME_INTERRUPTS();
 
        LOG_LWDEBUG("LWLockConditionalAcquire", lock, "failed");
        if (TRACE_POSTGRESQL_LWLOCK_CONDACQUIRE_FAIL_ENABLED())
            TRACE_POSTGRESQL_LWLOCK_CONDACQUIRE_FAIL(T_NAME(lock), mode);
    }
    else
    {
        /* Add lock to list of locks held by this backend */
        held_lwlocks[num_held_lwlocks].lock = lock;
        held_lwlocks[num_held_lwlocks++].mode = mode;
        if (TRACE_POSTGRESQL_LWLOCK_CONDACQUIRE_ENABLED())
            TRACE_POSTGRESQL_LWLOCK_CONDACQUIRE(T_NAME(lock), mode);
    }
    return !mustwait;
}

References Assert, elog, ERROR, held_lwlocks, HOLD_INTERRUPTS, LWLockHandle::lock, LOG_LWDEBUG, LW_EXCLUSIVE, LW_SHARED, LWLockAttemptLock(), MAX_SIMUL_LWLOCKS, LWLockHandle::mode, mode, num_held_lwlocks, PRINT_LWDEBUG, RESUME_INTERRUPTS, and T_NAME.

Referenced by ConditionalLockBuffer(), GetVictimBuffer(), pgstat_flush_io(), pgstat_flush_wal(), pgstat_lock_entry(), pgstat_lock_entry_shared(), pgstat_slru_flush(), ProcArrayEndTransaction(), SimpleLruWaitIO(), ss_report_location(), TransactionIdSetPageStatus(), and XLogNeedsFlush().

LWLockHeldByMe()

bool LWLockHeldByMe

(

LWLock *

lock

)

Definition at line 1895 of file lwlock.c.

{
    int         i;
 
    for (i = 0; i < num_held_lwlocks; i++)
    {
        if (held_lwlocks[i].lock == lock)
            return true;
    }
    return false;
}

References held_lwlocks, i, and num_held_lwlocks.

Referenced by alloc_object(), autovac_recalculate_workers_for_balance(), check_for_freed_segments_locked(), CompactCheckpointerRequestQueue(), delete_item(), DeleteLockTarget(), dshash_dump(), ensure_active_superblock(), FlushOneBuffer(), get_best_segment(), GetOldestSafeDecodingTransactionId(), GetSnapshotDataReuse(), init_span(), InvalidatePossiblyObsoleteSlot(), logicalrep_pa_worker_count(), logicalrep_sync_worker_count(), logicalrep_worker_find(), logicalrep_worker_wakeup_ptr(), logicalrep_workers_find(), MaintainLatestCompletedXid(), MaintainLatestCompletedXidRecovery(), make_new_segment(), MarkBufferDirtyHint(), OnConflict_CheckForSerializationFailure(), ProcArrayEndTransaction(), ProcArraySetReplicationSlotXmin(), ReleaseOneSerializableXact(), RemoveScratchTarget(), RemoveTargetIfNoLongerUsed(), resize(), RestoreScratchTarget(), SetNewSxactGlobalXmin(), SlruSelectLRUPage(), test_slru_page_readonly(), TransactionIdInRecentPast(), TwoPhaseGetGXact(), UnpinBufferNoOwner(), and VacuumUpdateCosts().

LWLockHeldByMeInMode()

bool LWLockHeldByMeInMode	(	LWLock *	lock,
		LWLockMode	mode
	)

Definition at line 1939 of file lwlock.c.

{
    int         i;
 
    for (i = 0; i < num_held_lwlocks; i++)
    {
        if (held_lwlocks[i].lock == lock && held_lwlocks[i].mode == mode)
            return true;
    }
    return false;
}

References held_lwlocks, i, mode, and num_held_lwlocks.

Referenced by BufferIsDirty(), BufferIsExclusiveLocked(), DeleteLockTarget(), dshash_delete_current(), dshash_delete_entry(), dshash_seq_next(), InvalidatePossiblyObsoleteSlot(), IsBufferCleanupOK(), logicalrep_worker_cleanup(), logicalrep_worker_stop_internal(), MarkAsPreparingGuts(), MarkBufferDirty(), pgstat_create_replslot(), pgstat_drop_replslot(), PrepareRedoAdd(), PrepareRedoRemove(), ProcArrayEndTransactionInternal(), ProcessTwoPhaseBuffer(), RemoveGXact(), SimpleLruReadPage(), SimpleLruZeroPage(), SlruInternalWritePage(), SyncRepWakeQueue(), TransactionIdSetPageStatusInternal(), TransactionIdSetStatusBit(), TransferPredicateLocksToNewTarget(), and write_relmap_file().

LWLockInitialize()

void LWLockInitialize	(	LWLock *	lock,
		int	tranche_id
	)

Definition at line 709 of file lwlock.c.

{
    pg_atomic_init_u32(&lock->state, LW_FLAG_RELEASE_OK);
#ifdef LOCK_DEBUG
    pg_atomic_init_u32(&lock->nwaiters, 0);
#endif
    lock->tranche = tranche_id;
    proclist_init(&lock->waiters);
}

References LW_FLAG_RELEASE_OK, pg_atomic_init_u32(), proclist_init(), LWLock::state, LWLock::tranche, and LWLock::waiters.

Referenced by apw_init_state(), create_internal(), dshash_create(), ExecAppendInitializeDSM(), ExecHashJoinInitializeDSM(), InitBufferPool(), InitializeLWLocks(), InitPredicateLocks(), InitProcGlobal(), pgstat_init_entry(), ReplicationOriginShmemInit(), ReplicationSlotsShmemInit(), SimpleLruInit(), StatsShmemInit(), sts_initialize(), tbm_prepare_shared_iterate(), tdr_init_shmem(), and XLOGShmemInit().

LWLockNewTrancheId()

int LWLockNewTrancheId

(

void

)

Definition at line 606 of file lwlock.c.

{
    int         result;
    int        *LWLockCounter;
 
    LWLockCounter = (int *) ((char *) MainLWLockArray - sizeof(int));
    SpinLockAcquire(ShmemLock);
    result = (*LWLockCounter)++;
    SpinLockRelease(ShmemLock);
 
    return result;
}

References MainLWLockArray, ShmemLock, SpinLockAcquire, and SpinLockRelease.

Referenced by apw_init_state(), InitializeLWLocks(), tdr_init_shmem(), test_basic(), test_create(), test_dsa_basic(), test_dsa_resowners(), test_empty(), test_random(), and test_slru_shmem_startup().

LWLockRegisterTranche()

void LWLockRegisterTranche	(	int	tranche_id,
		const char *	tranche_name
	)

Definition at line 630 of file lwlock.c.

{
    /* This should only be called for user-defined tranches. */
    if (tranche_id < LWTRANCHE_FIRST_USER_DEFINED)
        return;
 
    /* Convert to array index. */
    tranche_id -= LWTRANCHE_FIRST_USER_DEFINED;
 
    /* If necessary, create or enlarge array. */
    if (tranche_id >= LWLockTrancheNamesAllocated)
    {
        int         newalloc;
 
        newalloc = pg_nextpower2_32(Max(8, tranche_id + 1));
 
        if (LWLockTrancheNames == NULL)
            LWLockTrancheNames = (const char **)
                MemoryContextAllocZero(TopMemoryContext,
                                       newalloc * sizeof(char *));
        else
            LWLockTrancheNames =
                repalloc0_array(LWLockTrancheNames, const char *, LWLockTrancheNamesAllocated, newalloc);
        LWLockTrancheNamesAllocated = newalloc;
    }
 
    LWLockTrancheNames[tranche_id] = tranche_name;
}

References LWLockTrancheNames, LWLockTrancheNamesAllocated, LWTRANCHE_FIRST_USER_DEFINED, Max, MemoryContextAllocZero(), pg_nextpower2_32(), repalloc0_array, and TopMemoryContext.

Referenced by apw_init_shmem(), CreateLWLocks(), tdr_attach_shmem(), test_basic(), test_create(), test_dsa_basic(), test_dsa_resowners(), test_empty(), test_random(), and test_slru_shmem_startup().

LWLockRelease()

void LWLockRelease

(

LWLock *

lock

)

Definition at line 1783 of file lwlock.c.

{
    LWLockMode  mode;
    uint32      oldstate;
    bool        check_waiters;
    int         i;
 
    /*
     * Remove lock from list of locks held.  Usually, but not always, it will
     * be the latest-acquired lock; so search array backwards.
     */
    for (i = num_held_lwlocks; --i >= 0;)
        if (lock == held_lwlocks[i].lock)
            break;
 
    if (i < 0)
        elog(ERROR, "lock %s is not held", T_NAME(lock));
 
    mode = held_lwlocks[i].mode;
 
    num_held_lwlocks--;
    for (; i < num_held_lwlocks; i++)
        held_lwlocks[i] = held_lwlocks[i + 1];
 
    PRINT_LWDEBUG("LWLockRelease", lock, mode);
 
    /*
     * Release my hold on lock, after that it can immediately be acquired by
     * others, even if we still have to wakeup other waiters.
     */
    if (mode == LW_EXCLUSIVE)
        oldstate = pg_atomic_sub_fetch_u32(&lock->state, LW_VAL_EXCLUSIVE);
    else
        oldstate = pg_atomic_sub_fetch_u32(&lock->state, LW_VAL_SHARED);
 
    /* nobody else can have that kind of lock */
    Assert(!(oldstate & LW_VAL_EXCLUSIVE));
 
    if (TRACE_POSTGRESQL_LWLOCK_RELEASE_ENABLED())
        TRACE_POSTGRESQL_LWLOCK_RELEASE(T_NAME(lock));
 
    /*
     * We're still waiting for backends to get scheduled, don't wake them up
     * again.
     */
    if ((oldstate & (LW_FLAG_HAS_WAITERS | LW_FLAG_RELEASE_OK)) ==
        (LW_FLAG_HAS_WAITERS | LW_FLAG_RELEASE_OK) &&
        (oldstate & LW_LOCK_MASK) == 0)
        check_waiters = true;
    else
        check_waiters = false;
 
    /*
     * As waking up waiters requires the spinlock to be acquired, only do so
     * if necessary.
     */
    if (check_waiters)
    {
        /* XXX: remove before commit? */
        LOG_LWDEBUG("LWLockRelease", lock, "releasing waiters");
        LWLockWakeup(lock);
    }
 
    /*
     * Now okay to allow cancel/die interrupts.
     */
    RESUME_INTERRUPTS();
}

References Assert, elog, ERROR, held_lwlocks, i, LOG_LWDEBUG, LW_EXCLUSIVE, LW_FLAG_HAS_WAITERS, LW_FLAG_RELEASE_OK, LW_LOCK_MASK, LW_VAL_EXCLUSIVE, LW_VAL_SHARED, LWLockWakeup(), LWLockHandle::mode, mode, num_held_lwlocks, pg_atomic_sub_fetch_u32(), PRINT_LWDEBUG, RESUME_INTERRUPTS, LWLock::state, and T_NAME.

Referenced by _bt_end_vacuum(), _bt_start_vacuum(), _bt_vacuum_cycleid(), AbsorbSyncRequests(), ActivateCommitTs(), AdjustToFullTransactionId(), AdvanceNextFullTransactionIdPastXid(), AdvanceOldestClogXid(), AdvanceOldestCommitTsXid(), AdvanceXLInsertBuffer(), alloc_object(), AlterSystemSetConfigFile(), ApplyLauncherMain(), apw_detach_shmem(), apw_dump_now(), apw_load_buffers(), asyncQueueAddEntries(), asyncQueueAdvanceTail(), asyncQueueReadAllNotifications(), asyncQueueUnregister(), AtAbort_Twophase(), AtEOXact_LogicalRepWorkers(), AtPrepare_PredicateLocks(), attach_internal(), autoprewarm_main(), autoprewarm_start_worker(), AutoVacuumRequestWork(), AutoVacWorkerMain(), BackendPidGetProc(), BackendXidGetPid(), BecomeLockGroupLeader(), BecomeLockGroupMember(), BootStrapCLOG(), BootStrapMultiXact(), BootStrapSUBTRANS(), BufferAlloc(), CancelDBBackends(), check_for_freed_segments(), CheckDeadLock(), CheckForSerializableConflictOut(), CheckPointPredicate(), CheckPointRelationMap(), CheckPointReplicationOrigin(), CheckPointReplicationSlots(), CheckPointTwoPhase(), CheckTableForSerializableConflictIn(), CheckTargetForConflictsIn(), choose_next_subplan_for_leader(), choose_next_subplan_for_worker(), CleanupInvalidationState(), ClearOldPredicateLocks(), clog_redo(), commit_ts_redo(), ComputeXidHorizons(), consume_xids_shortcut(), copy_replication_slot(), CountDBBackends(), CountDBConnections(), CountOtherDBBackends(), CountUserBackends(), CreateCheckPoint(), CreateEndOfRecoveryRecord(), CreateInitDecodingContext(), CreatePredicateLock(), CreateRestartPoint(), DeactivateCommitTs(), DeleteChildTargetLocks(), DeleteLockTarget(), destroy_superblock(), do_autovacuum(), do_pg_backup_start(), do_pg_backup_stop(), do_start_worker(), DropAllPredicateLocksFromTable(), DropSubscription(), DropTableSpace(), dsa_allocate_extended(), dsa_dump(), dsa_free(), dsa_get_total_size(), dsa_pin(), dsa_release_in_place(), dsa_set_size_limit(), dsa_trim(), dsa_unpin(), dshash_delete_entry(), dshash_delete_key(), dshash_dump(), dshash_find(), dshash_find_or_insert(), dshash_release_lock(), dshash_seq_next(), dshash_seq_term(), dsm_attach(), dsm_create(), dsm_detach(), dsm_pin_segment(), dsm_unpin_segment(), ensure_active_superblock(), entry_reset(), EvictUnpinnedBuffer(), Exec_ListenPreCommit(), ExecParallelHashMergeCounters(), ExecParallelHashPopChunkQueue(), ExecParallelHashTupleAlloc(), ExecParallelHashTuplePrealloc(), ExpireAllKnownAssignedTransactionIds(), ExpireOldKnownAssignedTransactionIds(), ExpireTreeKnownAssignedTransactionIds(), ExtendBufferedRelShared(), ExtendCLOG(), ExtendCommitTs(), ExtendMultiXactMember(), ExtendMultiXactOffset(), ExtendSUBTRANS(), FastPathGetRelationLockEntry(), FastPathTransferRelationLocks(), find_multixact_start(), FindAndDropRelationBuffers(), FinishPreparedTransaction(), FlushDatabaseBuffers(), FlushRelationBuffers(), FlushRelationsAllBuffers(), ForceTransactionIdLimitUpdate(), ForwardSyncRequest(), FreeWorkerInfo(), get_local_synced_slots(), get_val_in_shmem(), GetBackgroundWorkerPid(), GetBackgroundWorkerTypeByPid(), GetBlockerStatusData(), GetConflictingVirtualXIDs(), GetCurrentVirtualXIDs(), GetLastImportantRecPtr(), GetLastSegSwitchData(), GetLatestCommitTsData(), GetLeaderApplyWorkerPid(), GetLockConflicts(), GetLockStatusData(), GetMultiXactIdMembers(), GetNewMultiXactId(), GetNewObjectId(), GetNewTransactionId(), GetOldestActiveTransactionId(), GetOldestMultiXactId(), GetOldestRestartPoint(), GetOldestSafeDecodingTransactionId(), GetOldestUnsummarizedLSN(), GetPredicateLockStatusData(), GetPreparedTransactionList(), GetRunningTransactionLocks(), GetSafeSnapshot(), GetSafeSnapshotBlockingPids(), GetSerializableTransactionSnapshotInt(), GetSnapshotData(), GetStrictOldestNonRemovableTransactionId(), GetVictimBuffer(), GetVirtualXIDsDelayingChkpt(), GetWaitEventExtensionIdentifier(), GetWaitEventExtensionNames(), GetWalSummarizerState(), HaveVirtualXIDsDelayingChkpt(), init_dsm_registry(), InjectionPointAttach(), InjectionPointDetach(), InjectionPointRun(), InstallXLogFileSegment(), InvalidateBuffer(), InvalidateObsoleteReplicationSlots(), InvalidatePossiblyObsoleteSlot(), InvalidateVictimBuffer(), IsInstallXLogFileSegmentActive(), KnownAssignedXidsCompress(), KnownAssignedXidsReset(), lock_twophase_recover(), LockAcquireExtended(), LockBuffer(), LockErrorCleanup(), LockGXact(), LockHasWaiters(), LockRefindAndRelease(), LockRelease(), LockReleaseAll(), LockWaiterCount(), logicalrep_launcher_attach_dshmem(), logicalrep_pa_worker_stop(), logicalrep_worker_attach(), logicalrep_worker_detach(), logicalrep_worker_launch(), logicalrep_worker_stop(), logicalrep_worker_stop_internal(), logicalrep_worker_wakeup(), LogStandbySnapshot(), LookupGXact(), LWLockReleaseAll(), LWLockReleaseClearVar(), MarkAsPrepared(), MarkAsPreparing(), MaybeExtendOffsetSlru(), multixact_redo(), MultiXactAdvanceNextMXact(), MultiXactGetCheckptMulti(), MultiXactIdSetOldestMember(), MultiXactIdSetOldestVisible(), MultiXactSetNextMXact(), OnConflict_CheckForSerializationFailure(), PageIsPredicateLocked(), perform_relmap_update(), pg_control_checkpoint(), pg_control_init(), pg_control_recovery(), pg_control_system(), pg_get_replication_slots(), pg_get_shmem_allocations(), pg_notification_queue_usage(), pg_show_replication_origin_status(), pg_stat_get_subscription(), pg_stat_statements_internal(), pg_xact_status(), pgss_shmem_startup(), pgss_store(), pgstat_archiver_reset_all_cb(), pgstat_archiver_snapshot_cb(), pgstat_bgwriter_reset_all_cb(), pgstat_bgwriter_snapshot_cb(), pgstat_build_snapshot(), pgstat_checkpointer_reset_all_cb(), pgstat_checkpointer_snapshot_cb(), pgstat_fetch_replslot(), pgstat_flush_io(), pgstat_flush_wal(), pgstat_io_reset_all_cb(), pgstat_io_snapshot_cb(), pgstat_reset_matching_entries(), pgstat_reset_replslot(), pgstat_reset_slru_counter_internal(), pgstat_slru_flush(), pgstat_slru_snapshot_cb(), pgstat_unlock_entry(), pgstat_wal_reset_all_cb(), pgstat_wal_snapshot_cb(), PostPrepare_Locks(), PostPrepare_MultiXact(), PostPrepare_Twophase(), PreCommit_CheckForSerializationFailure(), PreCommit_Notify(), predicatelock_twophase_recover(), PredicateLockPageSplit(), PredicateLockTwoPhaseFinish(), PrefetchSharedBuffer(), PrescanPreparedTransactions(), ProcArrayAdd(), ProcArrayApplyRecoveryInfo(), ProcArrayApplyXidAssignment(), ProcArrayClearTransaction(), ProcArrayEndTransaction(), ProcArrayGetReplicationSlotXmin(), ProcArrayGroupClearXid(), ProcArrayInstallImportedXmin(), ProcArrayInstallRestoredXmin(), ProcArrayRemove(), ProcArraySetReplicationSlotXmin(), process_syncing_tables_for_apply(), ProcKill(), ProcNumberGetTransactionIds(), ProcSleep(), ReachedEndOfBackup(), read_relmap_file(), ReadMultiXactCounts(), ReadMultiXactIdRange(), ReadNextFullTransactionId(), ReadNextMultiXactId(), ReadReplicationSlot(), RecordNewMultiXact(), RecoverPreparedTransactions(), RegisterDynamicBackgroundWorker(), RegisterPredicateLockingXid(), RelationCacheInitFilePostInvalidate(), RelationMapCopy(), RelationMapFinishBootstrap(), ReleaseOneSerializableXact(), ReleasePredicateLocks(), relmap_redo(), RemoveScratchTarget(), ReplicationOriginExitCleanup(), ReplicationSlotAcquire(), ReplicationSlotCleanup(), ReplicationSlotCreate(), ReplicationSlotDropPtr(), ReplicationSlotName(), ReplicationSlotRelease(), ReplicationSlotsComputeLogicalRestartLSN(), ReplicationSlotsComputeRequiredLSN(), ReplicationSlotsComputeRequiredXmin(), ReplicationSlotsCountDBSlots(), ReplicationSlotsDropDBSlots(), replorigin_advance(), replorigin_get_progress(), replorigin_session_advance(), replorigin_session_get_progress(), replorigin_session_reset(), replorigin_session_setup(), replorigin_state_clear(), resize(), RestoreScratchTarget(), restoreTwoPhaseData(), SaveSlotToPath(), SearchNamedReplicationSlot(), SerialAdd(), SerialGetMinConflictCommitSeqNo(), SerialInit(), SerialSetActiveSerXmin(), set_indexsafe_procflags(), set_val_in_shmem(), SetCommitTsLimit(), SetInstallXLogFileSegmentActive(), SetMultiXactIdLimit(), SetNextObjectId(), SetOffsetVacuumLimit(), SetTransactionIdLimit(), SetWalSummarizerLatch(), SetXidCommitTsInPage(), SharedInvalBackendInit(), ShmemInitStruct(), SICleanupQueue(), SIGetDataEntries(), SignalBackends(), SignalVirtualTransaction(), SIInsertDataEntries(), SimpleLruReadPage(), SimpleLruReadPage_ReadOnly(), SimpleLruTruncate(), SimpleLruWaitIO(), SimpleLruWriteAll(), SlruDeleteSegment(), SlruInternalWritePage(), SnapBuildInitialSnapshot(), ss_get_location(), ss_report_location(), StandbyRecoverPreparedTransactions(), StandbySlotsHaveCaughtup(), StartupDecodingContext(), StartupSUBTRANS(), StartupXLOG(), sts_parallel_scan_next(), SubTransGetParent(), SubTransSetParent(), SummarizeOldestCommittedSxact(), SummarizeWAL(), SwitchIntoArchiveRecovery(), synchronize_one_slot(), SyncOneBuffer(), SyncRepCancelWait(), SyncRepCleanupAtProcExit(), SyncRepReleaseWaiters(), SyncRepUpdateSyncStandbysDefined(), SyncRepWaitForLSN(), TablespaceCreateDbspace(), tbm_shared_iterate(), TerminateBackgroundWorker(), TerminateOtherDBBackends(), test_slru_page_exists(), test_slru_page_read(), test_slru_page_readonly(), test_slru_page_write(), TransactionGroupUpdateXidStatus(), TransactionIdGetCommitTsData(), TransactionIdGetStatus(), TransactionIdIsActive(), TransactionIdIsInProgress(), TransactionIdSetPageStatus(), TransactionTreeSetCommitTsData(), TransferPredicateLocksToNewTarget(), TrimCLOG(), TrimMultiXact(), TruncateMultiXact(), TwoPhaseGetGXact(), TwoPhaseGetXidByVirtualXID(), update_cached_xid_range(), update_synced_slots_inactive_since(), UpdateMinRecoveryPoint(), vac_truncate_clog(), vacuum_rel(), VacuumUpdateCosts(), validate_standby_slots(), VirtualXactLock(), VirtualXactLockTableCleanup(), VirtualXactLockTableInsert(), wait_for_relation_state_change(), wait_for_worker_state_change(), WaitEventExtensionNew(), WaitForReplicationWorkerAttach(), WaitForWalSummarization(), WaitOnLock(), WalSummarizerMain(), WalSummarizerShutdown(), write_relcache_init_file(), xact_redo(), XidCacheRemoveRunningXids(), xlog_redo(), XLogBackgroundFlush(), XLogFlush(), XLogNeedsFlush(), XLogReportParameters(), and XLogShutdownWalRcv().

LWLockReleaseAll()

void LWLockReleaseAll

(

void

)

Definition at line 1878 of file lwlock.c.

{
    while (num_held_lwlocks > 0)
    {
        HOLD_INTERRUPTS();      /* match the upcoming RESUME_INTERRUPTS */
 
        LWLockRelease(held_lwlocks[num_held_lwlocks - 1].lock);
    }
}

References held_lwlocks, HOLD_INTERRUPTS, LWLockRelease(), and num_held_lwlocks.

Referenced by AbortSubTransaction(), AbortTransaction(), AuxiliaryProcKill(), BackgroundWriterMain(), CheckpointerMain(), pgarch_archiveXlog(), ProcKill(), ShutdownAuxiliaryProcess(), WalSndErrorCleanup(), WalSummarizerMain(), and WalWriterMain().

LWLockReleaseClearVar()

void LWLockReleaseClearVar	(	LWLock *	lock,
		pg_atomic_uint64 *	valptr,
		uint64	val
	)

Definition at line 1856 of file lwlock.c.

{
    /*
     * Note that pg_atomic_exchange_u64 is a full barrier, so we're guaranteed
     * that the variable is updated before releasing the lock.
     */
    pg_atomic_exchange_u64(valptr, val);
 
    LWLockRelease(lock);
}

References LWLockRelease(), pg_atomic_exchange_u64(), and val.

Referenced by WALInsertLockRelease().

LWLockShmemSize()

Size LWLockShmemSize

(

void

)

Definition at line 423 of file lwlock.c.

{
    Size        size;
    int         i;
    int         numLocks = NUM_FIXED_LWLOCKS;
 
    /* Calculate total number of locks needed in the main array. */
    numLocks += NumLWLocksForNamedTranches();
 
    /* Space for the LWLock array. */
    size = mul_size(numLocks, sizeof(LWLockPadded));
 
    /* Space for dynamic allocation counter, plus room for alignment. */
    size = add_size(size, sizeof(int) + LWLOCK_PADDED_SIZE);
 
    /* space for named tranches. */
    size = add_size(size, mul_size(NamedLWLockTrancheRequests, sizeof(NamedLWLockTranche)));
 
    /* space for name of each tranche. */
    for (i = 0; i < NamedLWLockTrancheRequests; i++)
        size = add_size(size, strlen(NamedLWLockTrancheRequestArray[i].tranche_name) + 1);
 
    return size;
}

References add_size(), i, LWLOCK_PADDED_SIZE, mul_size(), NamedLWLockTrancheRequestArray, NamedLWLockTrancheRequests, NUM_FIXED_LWLOCKS, NumLWLocksForNamedTranches(), and size.

Referenced by CalculateShmemSize(), and CreateLWLocks().

LWLockUpdateVar()

void LWLockUpdateVar	(	LWLock *	lock,
		pg_atomic_uint64 *	valptr,
		uint64	val
	)

Definition at line 1722 of file lwlock.c.

{
    proclist_head wakeup;
    proclist_mutable_iter iter;
 
    PRINT_LWDEBUG("LWLockUpdateVar", lock, LW_EXCLUSIVE);
 
    /*
     * Note that pg_atomic_exchange_u64 is a full barrier, so we're guaranteed
     * that the variable is updated before waking up waiters.
     */
    pg_atomic_exchange_u64(valptr, val);
 
    proclist_init(&wakeup);
 
    LWLockWaitListLock(lock);
 
    Assert(pg_atomic_read_u32(&lock->state) & LW_VAL_EXCLUSIVE);
 
    /*
     * See if there are any LW_WAIT_UNTIL_FREE waiters that need to be woken
     * up. They are always in the front of the queue.
     */
    proclist_foreach_modify(iter, &lock->waiters, lwWaitLink)
    {
        PGPROC     *waiter = GetPGProcByNumber(iter.cur);
 
        if (waiter->lwWaitMode != LW_WAIT_UNTIL_FREE)
            break;
 
        proclist_delete(&lock->waiters, iter.cur, lwWaitLink);
        proclist_push_tail(&wakeup, iter.cur, lwWaitLink);
 
        /* see LWLockWakeup() */
        Assert(waiter->lwWaiting == LW_WS_WAITING);
        waiter->lwWaiting = LW_WS_PENDING_WAKEUP;
    }
 
    /* We are done updating shared state of the lock itself. */
    LWLockWaitListUnlock(lock);
 
    /*
     * Awaken any waiters I removed from the queue.
     */
    proclist_foreach_modify(iter, &wakeup, lwWaitLink)
    {
        PGPROC     *waiter = GetPGProcByNumber(iter.cur);
 
        proclist_delete(&wakeup, iter.cur, lwWaitLink);
        /* check comment in LWLockWakeup() about this barrier */
        pg_write_barrier();
        waiter->lwWaiting = LW_WS_NOT_WAITING;
        PGSemaphoreUnlock(waiter->sem);
    }
}

References Assert, proclist_mutable_iter::cur, GetPGProcByNumber, LW_EXCLUSIVE, LW_VAL_EXCLUSIVE, LW_WAIT_UNTIL_FREE, LW_WS_NOT_WAITING, LW_WS_PENDING_WAKEUP, LW_WS_WAITING, LWLockWaitListLock(), LWLockWaitListUnlock(), PGPROC::lwWaiting, PGPROC::lwWaitMode, pg_atomic_exchange_u64(), pg_atomic_read_u32(), pg_write_barrier, PGSemaphoreUnlock(), PRINT_LWDEBUG, proclist_delete, proclist_foreach_modify, proclist_init(), proclist_push_tail, PGPROC::sem, LWLock::state, val, LWLock::waiters, and wakeup.

Referenced by WALInsertLockAcquireExclusive(), and WALInsertLockUpdateInsertingAt().

LWLockWaitForVar()

bool LWLockWaitForVar	(	LWLock *	lock,
		pg_atomic_uint64 *	valptr,
		uint64	oldval,
		uint64 *	newval
	)

Definition at line 1586 of file lwlock.c.

{
    PGPROC     *proc = MyProc;
    int         extraWaits = 0;
    bool        result = false;
#ifdef LWLOCK_STATS
    lwlock_stats *lwstats;
 
    lwstats = get_lwlock_stats_entry(lock);
#endif
 
    PRINT_LWDEBUG("LWLockWaitForVar", lock, LW_WAIT_UNTIL_FREE);
 
    /*
     * Lock out cancel/die interrupts while we sleep on the lock.  There is no
     * cleanup mechanism to remove us from the wait queue if we got
     * interrupted.
     */
    HOLD_INTERRUPTS();
 
    /*
     * Loop here to check the lock's status after each time we are signaled.
     */
    for (;;)
    {
        bool        mustwait;
 
        mustwait = LWLockConflictsWithVar(lock, valptr, oldval, newval,
                                          &result);
 
        if (!mustwait)
            break;              /* the lock was free or value didn't match */
 
        /*
         * Add myself to wait queue. Note that this is racy, somebody else
         * could wakeup before we're finished queuing. NB: We're using nearly
         * the same twice-in-a-row lock acquisition protocol as
         * LWLockAcquire(). Check its comments for details. The only
         * difference is that we also have to check the variable's values when
         * checking the state of the lock.
         */
        LWLockQueueSelf(lock, LW_WAIT_UNTIL_FREE);
 
        /*
         * Set RELEASE_OK flag, to make sure we get woken up as soon as the
         * lock is released.
         */
        pg_atomic_fetch_or_u32(&lock->state, LW_FLAG_RELEASE_OK);
 
        /*
         * We're now guaranteed to be woken up if necessary. Recheck the lock
         * and variables state.
         */
        mustwait = LWLockConflictsWithVar(lock, valptr, oldval, newval,
                                          &result);
 
        /* Ok, no conflict after we queued ourselves. Undo queueing. */
        if (!mustwait)
        {
            LOG_LWDEBUG("LWLockWaitForVar", lock, "free, undoing queue");
 
            LWLockDequeueSelf(lock);
            break;
        }
 
        /*
         * Wait until awakened.
         *
         * It is possible that we get awakened for a reason other than being
         * signaled by LWLockRelease.  If so, loop back and wait again.  Once
         * we've gotten the LWLock, re-increment the sema by the number of
         * additional signals received.
         */
        LOG_LWDEBUG("LWLockWaitForVar", lock, "waiting");
 
#ifdef LWLOCK_STATS
        lwstats->block_count++;
#endif
 
        LWLockReportWaitStart(lock);
        if (TRACE_POSTGRESQL_LWLOCK_WAIT_START_ENABLED())
            TRACE_POSTGRESQL_LWLOCK_WAIT_START(T_NAME(lock), LW_EXCLUSIVE);
 
        for (;;)
        {
            PGSemaphoreLock(proc->sem);
            if (proc->lwWaiting == LW_WS_NOT_WAITING)
                break;
            extraWaits++;
        }
 
#ifdef LOCK_DEBUG
        {
            /* not waiting anymore */
            uint32      nwaiters PG_USED_FOR_ASSERTS_ONLY = pg_atomic_fetch_sub_u32(&lock->nwaiters, 1);
 
            Assert(nwaiters < MAX_BACKENDS);
        }
#endif
 
        if (TRACE_POSTGRESQL_LWLOCK_WAIT_DONE_ENABLED())
            TRACE_POSTGRESQL_LWLOCK_WAIT_DONE(T_NAME(lock), LW_EXCLUSIVE);
        LWLockReportWaitEnd();
 
        LOG_LWDEBUG("LWLockWaitForVar", lock, "awakened");
 
        /* Now loop back and check the status of the lock again. */
    }
 
    /*
     * Fix the process wait semaphore's count for any absorbed wakeups.
     */
    while (extraWaits-- > 0)
        PGSemaphoreUnlock(proc->sem);
 
    /*
     * Now okay to allow cancel/die interrupts.
     */
    RESUME_INTERRUPTS();
 
    return result;
}

References Assert, HOLD_INTERRUPTS, LOG_LWDEBUG, LW_EXCLUSIVE, LW_FLAG_RELEASE_OK, LW_WAIT_UNTIL_FREE, LW_WS_NOT_WAITING, LWLockConflictsWithVar(), LWLockDequeueSelf(), LWLockQueueSelf(), LWLockReportWaitEnd(), LWLockReportWaitStart(), PGPROC::lwWaiting, MAX_BACKENDS, MyProc, newval, pg_atomic_fetch_or_u32(), pg_atomic_fetch_sub_u32(), PG_USED_FOR_ASSERTS_ONLY, PGSemaphoreLock(), PGSemaphoreUnlock(), PRINT_LWDEBUG, RESUME_INTERRUPTS, PGPROC::sem, LWLock::state, and T_NAME.

Referenced by WaitXLogInsertionsToFinish().

RequestNamedLWLockTranche()

void RequestNamedLWLockTranche	(	const char *	tranche_name,
		int	num_lwlocks
	)

Definition at line 672 of file lwlock.c.

{
    NamedLWLockTrancheRequest *request;
 
    if (!process_shmem_requests_in_progress)
        elog(FATAL, "cannot request additional LWLocks outside shmem_request_hook");
 
    if (NamedLWLockTrancheRequestArray == NULL)
    {
        NamedLWLockTrancheRequestsAllocated = 16;
        NamedLWLockTrancheRequestArray = (NamedLWLockTrancheRequest *)
            MemoryContextAlloc(TopMemoryContext,
                               NamedLWLockTrancheRequestsAllocated
                               * sizeof(NamedLWLockTrancheRequest));
    }
 
    if (NamedLWLockTrancheRequests >= NamedLWLockTrancheRequestsAllocated)
    {
        int         i = pg_nextpower2_32(NamedLWLockTrancheRequests + 1);
 
        NamedLWLockTrancheRequestArray = (NamedLWLockTrancheRequest *)
            repalloc(NamedLWLockTrancheRequestArray,
                     i * sizeof(NamedLWLockTrancheRequest));
        NamedLWLockTrancheRequestsAllocated = i;
    }
 
    request = &NamedLWLockTrancheRequestArray[NamedLWLockTrancheRequests];
    Assert(strlen(tranche_name) + 1 <= NAMEDATALEN);
    strlcpy(request->tranche_name, tranche_name, NAMEDATALEN);
    request->num_lwlocks = num_lwlocks;
    NamedLWLockTrancheRequests++;
}

References Assert, elog, FATAL, i, MemoryContextAlloc(), NAMEDATALEN, NamedLWLockTrancheRequestArray, NamedLWLockTrancheRequests, NamedLWLockTrancheRequestsAllocated, NamedLWLockTrancheRequest::num_lwlocks, pg_nextpower2_32(), process_shmem_requests_in_progress, repalloc(), strlcpy(), TopMemoryContext, and NamedLWLockTrancheRequest::tranche_name.

Referenced by pgss_shmem_request().

StaticAssertDecl()

StaticAssertDecl	(	sizeof(LWLock)<=	LWLOCK_PADDED_SIZE,
		"Miscalculated LWLock padding"
	)

Variable Documentation

MainLWLockArray

PGDLLIMPORT LWLockPadded* MainLWLockArray

extern

Definition at line 191 of file lwlock.c.

Referenced by BufMappingPartitionLock(), BufMappingPartitionLockByIndex(), CreateLWLocks(), GetNamedLWLockTranche(), InitializeLWLocks(), and LWLockNewTrancheId().

NamedLWLockTrancheArray

PGDLLIMPORT NamedLWLockTranche* NamedLWLockTrancheArray

extern

Definition at line 230 of file lwlock.c.

Referenced by CreateLWLocks(), and InitializeLWLocks().

NamedLWLockTrancheRequests

PGDLLIMPORT int NamedLWLockTrancheRequests

extern

Definition at line 227 of file lwlock.c.

Referenced by CreateLWLocks(), GetNamedLWLockTranche(), InitializeLWLocks(), LWLockShmemSize(), NumLWLocksForNamedTranches(), and RequestNamedLWLockTranche().