lwlock.c File Reference

#include "postgres.h"
#include "miscadmin.h"
#include "pg_trace.h"
#include "pgstat.h"
#include "port/pg_bitutils.h"
#include "storage/proc.h"
#include "storage/proclist.h"
#include "storage/procnumber.h"
#include "storage/spin.h"
#include "utils/memutils.h"
#include "storage/lwlocklist.h"

Include dependency graph for lwlock.c:

Go to the source code of this file.

Data Structures
struct	LWLockHandle
struct	NamedLWLockTrancheRequest

Macros
#define	LW_FLAG_HAS_WAITERS   ((uint32) 1 << 31)
#define	LW_FLAG_WAKE_IN_PROGRESS   ((uint32) 1 << 30)
#define	LW_FLAG_LOCKED   ((uint32) 1 << 29)
#define	LW_FLAG_BITS   3
#define	LW_FLAG_MASK   (((1<<LW_FLAG_BITS)-1)<<(32-LW_FLAG_BITS))
#define	LW_VAL_EXCLUSIVE   (MAX_BACKENDS + 1)
#define	LW_VAL_SHARED   1
#define	LW_SHARED_MASK   MAX_BACKENDS
#define	LW_LOCK_MASK   (MAX_BACKENDS | LW_VAL_EXCLUSIVE)
#define	PG_LWLOCK(id, lockname)   [id] = CppAsString(lockname),
#define	PG_LWLOCKTRANCHE(id, lockname)   [LWTRANCHE_##id] = CppAsString(lockname),
#define	MAX_SIMUL_LWLOCKS   200
#define	MAX_NAMED_TRANCHES   256
#define	T_NAME(lock)    GetLWTrancheName((lock)->tranche)
#define	PRINT_LWDEBUG(a, b, c)   ((void)0)
#define	LOG_LWDEBUG(a, b, c)   ((void)0)

Typedefs
typedef struct LWLockHandle	LWLockHandle
typedef struct NamedLWLockTrancheRequest	NamedLWLockTrancheRequest

Functions
	StaticAssertDecl (((MAX_BACKENDS+1) &MAX_BACKENDS)==0, "MAX_BACKENDS + 1 needs to be a power of 2")
	StaticAssertDecl ((MAX_BACKENDS &LW_FLAG_MASK)==0, "MAX_BACKENDS and LW_FLAG_MASK overlap")
	StaticAssertDecl ((LW_VAL_EXCLUSIVE &LW_FLAG_MASK)==0, "LW_VAL_EXCLUSIVE and LW_FLAG_MASK overlap")
	StaticAssertDecl (lengthof(BuiltinTrancheNames)==LWTRANCHE_FIRST_USER_DEFINED, "missing entries in BuiltinTrancheNames[]")
static void	InitializeLWLocks (void)
static void	LWLockReportWaitStart (LWLock *lock)
static void	LWLockReportWaitEnd (void)
static const char *	GetLWTrancheName (uint16 trancheId)
static int	NumLWLocksForNamedTranches (void)
Size	LWLockShmemSize (void)
void	CreateLWLocks (void)
void	InitLWLockAccess (void)
LWLockPadded *	GetNamedLWLockTranche (const char *tranche_name)
int	LWLockNewTrancheId (const char *name)
void	RequestNamedLWLockTranche (const char *tranche_name, int num_lwlocks)
void	LWLockInitialize (LWLock *lock, int tranche_id)
const char *	GetLWLockIdentifier (uint32 classId, uint16 eventId)
static bool	LWLockAttemptLock (LWLock *lock, LWLockMode mode)
static void	LWLockWaitListLock (LWLock *lock)
static void	LWLockWaitListUnlock (LWLock *lock)
static void	LWLockWakeup (LWLock *lock)
static void	LWLockQueueSelf (LWLock *lock, LWLockMode mode)
static void	LWLockDequeueSelf (LWLock *lock)
bool	LWLockAcquire (LWLock *lock, LWLockMode mode)
bool	LWLockConditionalAcquire (LWLock *lock, LWLockMode mode)
bool	LWLockAcquireOrWait (LWLock *lock, LWLockMode mode)
static bool	LWLockConflictsWithVar (LWLock *lock, pg_atomic_uint64 *valptr, uint64 oldval, uint64 *newval, bool *result)
bool	LWLockWaitForVar (LWLock *lock, pg_atomic_uint64 *valptr, uint64 oldval, uint64 *newval)
void	LWLockUpdateVar (LWLock *lock, pg_atomic_uint64 *valptr, uint64 val)
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)

Variables
static const char *const	BuiltinTrancheNames []
char **	LWLockTrancheNames = NULL
LWLockPadded *	MainLWLockArray = NULL
static int	num_held_lwlocks = 0
static LWLockHandle	held_lwlocks [MAX_SIMUL_LWLOCKS]
int	NamedLWLockTrancheRequests = 0
NamedLWLockTrancheRequest *	NamedLWLockTrancheRequestArray = NULL
static NamedLWLockTrancheRequest *	LocalNamedLWLockTrancheRequestArray = NULL
int *	LWLockCounter = NULL
static int	LocalLWLockCounter

Macro Definition Documentation

LOG_LWDEBUG

#define LOG_LWDEBUG	(		a,
			b,
			c
	)		((void)0)

Definition at line 276 of file lwlock.c.

LW_FLAG_BITS

#define LW_FLAG_BITS   3

Definition at line 97 of file lwlock.c.

LW_FLAG_HAS_WAITERS

#define LW_FLAG_HAS_WAITERS   ((uint32) 1 << 31)

Definition at line 94 of file lwlock.c.

LW_FLAG_LOCKED

#define LW_FLAG_LOCKED   ((uint32) 1 << 29)

Definition at line 96 of file lwlock.c.

LW_FLAG_MASK

#define LW_FLAG_MASK   (((1<<LW_FLAG_BITS)-1)<<(32-LW_FLAG_BITS))

Definition at line 98 of file lwlock.c.

LW_FLAG_WAKE_IN_PROGRESS

#define LW_FLAG_WAKE_IN_PROGRESS   ((uint32) 1 << 30)

Definition at line 95 of file lwlock.c.

LW_LOCK_MASK

#define LW_LOCK_MASK   (MAX_BACKENDS | LW_VAL_EXCLUSIVE)

Definition at line 106 of file lwlock.c.

LW_SHARED_MASK

#define LW_SHARED_MASK   MAX_BACKENDS

Definition at line 105 of file lwlock.c.

LW_VAL_EXCLUSIVE

#define LW_VAL_EXCLUSIVE   (MAX_BACKENDS + 1)

Definition at line 101 of file lwlock.c.

LW_VAL_SHARED

#define LW_VAL_SHARED   1

Definition at line 102 of file lwlock.c.

MAX_NAMED_TRANCHES

#define MAX_NAMED_TRANCHES   256

Definition at line 204 of file lwlock.c.

MAX_SIMUL_LWLOCKS

#define MAX_SIMUL_LWLOCKS   200

Definition at line 168 of file lwlock.c.

PG_LWLOCK

#define PG_LWLOCK	(		id,
			lockname
	)		[id] = CppAsString(lockname),

PG_LWLOCKTRANCHE

#define PG_LWLOCKTRANCHE	(		id,
			lockname
	)		[LWTRANCHE_##id] = CppAsString(lockname),

PRINT_LWDEBUG

#define PRINT_LWDEBUG	(		a,
			b,
			c
	)		((void)0)

Definition at line 275 of file lwlock.c.

T_NAME

#define T_NAME

(

lock

)

GetLWTrancheName((lock)->tranche)

Definition at line 211 of file lwlock.c.

{
    int         tranche;
    void       *instance;
}           lwlock_stats_key;
 
typedef struct lwlock_stats
{
    lwlock_stats_key key;
    int         sh_acquire_count;
    int         ex_acquire_count;
    int         block_count;
    int         dequeue_self_count;
    int         spin_delay_count;
}           lwlock_stats;
 
static HTAB *lwlock_stats_htab;
static lwlock_stats lwlock_stats_dummy;
#endif
 
#ifdef LOCK_DEBUG
bool        Trace_lwlocks = false;
 
inline static void
PRINT_LWDEBUG(const char *where, LWLock *lock, LWLockMode mode)
{
    /* hide statement & context here, otherwise the log is just too verbose */
    if (Trace_lwlocks)
    {
        uint32      state = pg_atomic_read_u32(&lock->state);
 
        ereport(LOG,
                (errhidestmt(true),
                 errhidecontext(true),
                 errmsg_internal("%d: %s(%s %p): excl %u shared %u haswaiters %u waiters %u waking %d",
                                 MyProcPid,
                                 where, T_NAME(lock), lock,
                                 (state & LW_VAL_EXCLUSIVE) != 0,
                                 state & LW_SHARED_MASK,
                                 (state & LW_FLAG_HAS_WAITERS) != 0,
                                 pg_atomic_read_u32(&lock->nwaiters),
                                 (state & LW_FLAG_WAKE_IN_PROGRESS) != 0)));
    }
}
 
inline static void
LOG_LWDEBUG(const char *where, LWLock *lock, const char *msg)
{
    /* hide statement & context here, otherwise the log is just too verbose */
    if (Trace_lwlocks)
    {
        ereport(LOG,
                (errhidestmt(true),
                 errhidecontext(true),
                 errmsg_internal("%s(%s %p): %s", where,
                                 T_NAME(lock), lock, msg)));
    }
}
 
#else                           /* not LOCK_DEBUG */
#define PRINT_LWDEBUG(a,b,c) ((void)0)
#define LOG_LWDEBUG(a,b,c) ((void)0)
#endif                          /* LOCK_DEBUG */
 
#ifdef LWLOCK_STATS
 
static void init_lwlock_stats(void);
static void print_lwlock_stats(int code, Datum arg);
static lwlock_stats * get_lwlock_stats_entry(LWLock *lock);
 
static void
init_lwlock_stats(void)
{
    HASHCTL     ctl;
    static MemoryContext lwlock_stats_cxt = NULL;
    static bool exit_registered = false;
 
    if (lwlock_stats_cxt != NULL)
        MemoryContextDelete(lwlock_stats_cxt);
 
    /*
     * The LWLock stats will be updated within a critical section, which
     * requires allocating new hash entries. Allocations within a critical
     * section are normally not allowed because running out of memory would
     * lead to a PANIC, but LWLOCK_STATS is debugging code that's not normally
     * turned on in production, so that's an acceptable risk. The hash entries
     * are small, so the risk of running out of memory is minimal in practice.
     */
    lwlock_stats_cxt = AllocSetContextCreate(TopMemoryContext,
                                             "LWLock stats",
                                             ALLOCSET_DEFAULT_SIZES);
    MemoryContextAllowInCriticalSection(lwlock_stats_cxt, true);
 
    ctl.keysize = sizeof(lwlock_stats_key);
    ctl.entrysize = sizeof(lwlock_stats);
    ctl.hcxt = lwlock_stats_cxt;
    lwlock_stats_htab = hash_create("lwlock stats", 16384, &ctl,
                                    HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);
    if (!exit_registered)
    {
        on_shmem_exit(print_lwlock_stats, 0);
        exit_registered = true;
    }
}
 
static void
print_lwlock_stats(int code, Datum arg)
{
    HASH_SEQ_STATUS scan;
    lwlock_stats *lwstats;
 
    hash_seq_init(&scan, lwlock_stats_htab);
 
    /* Grab an LWLock to keep different backends from mixing reports */
    LWLockAcquire(&MainLWLockArray[0].lock, LW_EXCLUSIVE);
 
    while ((lwstats = (lwlock_stats *) hash_seq_search(&scan)) != NULL)
    {
        fprintf(stderr,
                "PID %d lwlock %s %p: shacq %u exacq %u blk %u spindelay %u dequeue self %u\n",
                MyProcPid, GetLWTrancheName(lwstats->key.tranche),
                lwstats->key.instance, lwstats->sh_acquire_count,
                lwstats->ex_acquire_count, lwstats->block_count,
                lwstats->spin_delay_count, lwstats->dequeue_self_count);
    }
 
    LWLockRelease(&MainLWLockArray[0].lock);
}
 
static lwlock_stats *
get_lwlock_stats_entry(LWLock *lock)
{
    lwlock_stats_key key;
    lwlock_stats *lwstats;
    bool        found;
 
    /*
     * During shared memory initialization, the hash table doesn't exist yet.
     * Stats of that phase aren't very interesting, so just collect operations
     * on all locks in a single dummy entry.
     */
    if (lwlock_stats_htab == NULL)
        return &lwlock_stats_dummy;
 
    /* Fetch or create the entry. */
    MemSet(&key, 0, sizeof(key));
    key.tranche = lock->tranche;
    key.instance = lock;
    lwstats = hash_search(lwlock_stats_htab, &key, HASH_ENTER, &found);
    if (!found)
    {
        lwstats->sh_acquire_count = 0;
        lwstats->ex_acquire_count = 0;
        lwstats->block_count = 0;
        lwstats->dequeue_self_count = 0;
        lwstats->spin_delay_count = 0;
    }
    return lwstats;
}
#endif                          /* LWLOCK_STATS */
 
 
/*
 * Compute number of LWLocks required by named tranches.  These will be
 * allocated in the main array.
 */
static int
NumLWLocksForNamedTranches(void)
{
    int         numLocks = 0;
    int         i;
 
    for (i = 0; i < NamedLWLockTrancheRequests; i++)
        numLocks += NamedLWLockTrancheRequestArray[i].num_lwlocks;
 
    return numLocks;
}
 
/*
 * Compute shmem space needed for LWLocks and named tranches.
 */
Size
LWLockShmemSize(void)
{
    Size        size;
    int         numLocks = NUM_FIXED_LWLOCKS;
 
    /*
     * If re-initializing shared memory, the request array will no longer be
     * accessible, so switch to the copy in postmaster's local memory.  We'll
     * copy it back into shared memory later when CreateLWLocks() is called
     * again.
     */
    if (LocalNamedLWLockTrancheRequestArray)
        NamedLWLockTrancheRequestArray = LocalNamedLWLockTrancheRequestArray;
 
    /* Calculate total number of locks needed in the main array. */
    numLocks += NumLWLocksForNamedTranches();
 
    /* Space for dynamic allocation counter. */
    size = MAXALIGN(sizeof(int));
 
    /* Space for named tranches. */
    size = add_size(size, mul_size(MAX_NAMED_TRANCHES, sizeof(char *)));
    size = add_size(size, mul_size(MAX_NAMED_TRANCHES, NAMEDATALEN));
 
    /*
     * Make space for named tranche requests.  This is done for the benefit of
     * EXEC_BACKEND builds, which otherwise wouldn't be able to call
     * GetNamedLWLockTranche() outside postmaster.
     */
    size = add_size(size, mul_size(NamedLWLockTrancheRequests,
                                   sizeof(NamedLWLockTrancheRequest)));
 
    /* Space for the LWLock array, plus room for cache line alignment. */
    size = add_size(size, LWLOCK_PADDED_SIZE);
    size = add_size(size, mul_size(numLocks, sizeof(LWLockPadded)));
 
    return size;
}
 
/*
 * Allocate shmem space for the main LWLock array and all tranches and
 * initialize it.
 */
void
CreateLWLocks(void)
{
    if (!IsUnderPostmaster)
    {
        Size        spaceLocks = LWLockShmemSize();
        char       *ptr;
 
        /* Allocate space */
        ptr = (char *) ShmemAlloc(spaceLocks);
 
        /* Initialize the dynamic-allocation counter for tranches */
        LWLockCounter = (int *) ptr;
        *LWLockCounter = LWTRANCHE_FIRST_USER_DEFINED;
        ptr += MAXALIGN(sizeof(int));
 
        /* Initialize tranche names */
        LWLockTrancheNames = (char **) ptr;
        ptr += MAX_NAMED_TRANCHES * sizeof(char *);
        for (int i = 0; i < MAX_NAMED_TRANCHES; i++)
        {
            LWLockTrancheNames[i] = ptr;
            ptr += NAMEDATALEN;
        }
 
        /*
         * Move named tranche requests to shared memory.  This is done for the
         * benefit of EXEC_BACKEND builds, which otherwise wouldn't be able to
         * call GetNamedLWLockTranche() outside postmaster.
         */
        if (NamedLWLockTrancheRequests > 0)
        {
            /*
             * Save the pointer to the request array in postmaster's local
             * memory.  We'll need it if we ever need to re-initialize shared
             * memory after a crash.
             */
            LocalNamedLWLockTrancheRequestArray = NamedLWLockTrancheRequestArray;
 
            memcpy(ptr, NamedLWLockTrancheRequestArray,
                   NamedLWLockTrancheRequests * sizeof(NamedLWLockTrancheRequest));
            NamedLWLockTrancheRequestArray = (NamedLWLockTrancheRequest *) ptr;
            ptr += NamedLWLockTrancheRequests * sizeof(NamedLWLockTrancheRequest);
        }
 
        /* Ensure desired alignment of LWLock array */
        ptr += LWLOCK_PADDED_SIZE - ((uintptr_t) ptr) % LWLOCK_PADDED_SIZE;
        MainLWLockArray = (LWLockPadded *) ptr;
 
        /* Initialize all LWLocks */
        InitializeLWLocks();
    }
}
 
/*
 * Initialize LWLocks that are fixed and those belonging to named tranches.
 */
static void
InitializeLWLocks(void)
{
    int         id;
    int         i;
    int         j;
    LWLockPadded *lock;
 
    /* Initialize all individual LWLocks in main array */
    for (id = 0, lock = MainLWLockArray; id < NUM_INDIVIDUAL_LWLOCKS; id++, lock++)
        LWLockInitialize(&lock->lock, id);
 
    /* Initialize buffer mapping LWLocks in main array */
    lock = MainLWLockArray + BUFFER_MAPPING_LWLOCK_OFFSET;
    for (id = 0; id < NUM_BUFFER_PARTITIONS; id++, lock++)
        LWLockInitialize(&lock->lock, LWTRANCHE_BUFFER_MAPPING);
 
    /* Initialize lmgrs' LWLocks in main array */
    lock = MainLWLockArray + LOCK_MANAGER_LWLOCK_OFFSET;
    for (id = 0; id < NUM_LOCK_PARTITIONS; id++, lock++)
        LWLockInitialize(&lock->lock, LWTRANCHE_LOCK_MANAGER);
 
    /* Initialize predicate lmgrs' LWLocks in main array */
    lock = MainLWLockArray + PREDICATELOCK_MANAGER_LWLOCK_OFFSET;
    for (id = 0; id < NUM_PREDICATELOCK_PARTITIONS; id++, lock++)
        LWLockInitialize(&lock->lock, LWTRANCHE_PREDICATE_LOCK_MANAGER);
 
    /*
     * Copy the info about any named tranches into shared memory (so that
     * other processes can see it), and initialize the requested LWLocks.
     */
    if (NamedLWLockTrancheRequests > 0)
    {
        lock = &MainLWLockArray[NUM_FIXED_LWLOCKS];
 
        for (i = 0; i < NamedLWLockTrancheRequests; i++)
        {
            NamedLWLockTrancheRequest *request;
            int         tranche;
 
            request = &NamedLWLockTrancheRequestArray[i];
            tranche = LWLockNewTrancheId(request->tranche_name);
 
            for (j = 0; j < request->num_lwlocks; j++, lock++)
                LWLockInitialize(&lock->lock, tranche);
        }
    }
}
 
/*
 * InitLWLockAccess - initialize backend-local state needed to hold LWLocks
 */
void
InitLWLockAccess(void)
{
#ifdef LWLOCK_STATS
    init_lwlock_stats();
#endif
}
 
/*
 * GetNamedLWLockTranche - returns the base address of LWLock from the
 *      specified tranche.
 *
 * Caller needs to retrieve the requested number of LWLocks starting from
 * the base lock address returned by this API.  This can be used for
 * tranches that are requested by using RequestNamedLWLockTranche() API.
 */
LWLockPadded *
GetNamedLWLockTranche(const char *tranche_name)
{
    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;
}
 
/*
 * Allocate a new tranche ID with the provided name.
 */
int
LWLockNewTrancheId(const char *name)
{
    int         result;
 
    if (!name)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_NAME),
                 errmsg("tranche name cannot be NULL")));
 
    if (strlen(name) >= NAMEDATALEN)
        ereport(ERROR,
                (errcode(ERRCODE_NAME_TOO_LONG),
                 errmsg("tranche name too long"),
                 errdetail("LWLock tranche names must be no longer than %d bytes.",
                           NAMEDATALEN - 1)));
 
    /*
     * We use the ShmemLock spinlock to protect LWLockCounter and
     * LWLockTrancheNames.
     */
    SpinLockAcquire(ShmemLock);
 
    if (*LWLockCounter - LWTRANCHE_FIRST_USER_DEFINED >= MAX_NAMED_TRANCHES)
    {
        SpinLockRelease(ShmemLock);
        ereport(ERROR,
                (errmsg("maximum number of tranches already registered"),
                 errdetail("No more than %d tranches may be registered.",
                           MAX_NAMED_TRANCHES)));
    }
 
    result = (*LWLockCounter)++;
    LocalLWLockCounter = *LWLockCounter;
    strlcpy(LWLockTrancheNames[result - LWTRANCHE_FIRST_USER_DEFINED], name, NAMEDATALEN);
 
    SpinLockRelease(ShmemLock);
 
    return result;
}
 
/*
 * RequestNamedLWLockTranche
 *      Request that extra LWLocks be allocated during postmaster
 *      startup.
 *
 * This may only be called via the shmem_request_hook of a library that is
 * loaded into the postmaster via shared_preload_libraries.  Calls from
 * elsewhere will fail.
 *
 * The tranche name will be user-visible as a wait event name, so try to
 * use a name that fits the style for those.
 */
void
RequestNamedLWLockTranche(const char *tranche_name, int num_lwlocks)
{
    NamedLWLockTrancheRequest *request;
    static int  NamedLWLockTrancheRequestsAllocated;
 
    if (!process_shmem_requests_in_progress)
        elog(FATAL, "cannot request additional LWLocks outside shmem_request_hook");
 
    if (!tranche_name)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_NAME),
                 errmsg("tranche name cannot be NULL")));
 
    if (strlen(tranche_name) >= NAMEDATALEN)
        ereport(ERROR,
                (errcode(ERRCODE_NAME_TOO_LONG),
                 errmsg("tranche name too long"),
                 errdetail("LWLock tranche names must be no longer than %d bytes.",
                           NAMEDATALEN - 1)));
 
    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];
    strlcpy(request->tranche_name, tranche_name, NAMEDATALEN);
    request->num_lwlocks = num_lwlocks;
    NamedLWLockTrancheRequests++;
}
 
/*
 * LWLockInitialize - initialize a new lwlock; it's initially unlocked
 */
void
LWLockInitialize(LWLock *lock, int tranche_id)
{
    /* verify the tranche_id is valid */
    (void) GetLWTrancheName(tranche_id);
 
    pg_atomic_init_u32(&lock->state, 0);
#ifdef LOCK_DEBUG
    pg_atomic_init_u32(&lock->nwaiters, 0);
#endif
    lock->tranche = tranche_id;
    proclist_init(&lock->waiters);
}
 
/*
 * Report start of wait event for light-weight locks.
 *
 * This function will be used by all the light-weight lock calls which
 * needs to wait to acquire the lock.  This function distinguishes wait
 * event based on tranche and lock id.
 */
static inline void
LWLockReportWaitStart(LWLock *lock)
{
    pgstat_report_wait_start(PG_WAIT_LWLOCK | lock->tranche);
}
 
/*
 * Report end of wait event for light-weight locks.
 */
static inline void
LWLockReportWaitEnd(void)
{
    pgstat_report_wait_end();
}
 
/*
 * Return the name of an LWLock tranche.
 */
static const char *
GetLWTrancheName(uint16 trancheId)
{
    /* Built-in tranche or individual LWLock? */
    if (trancheId < LWTRANCHE_FIRST_USER_DEFINED)
        return BuiltinTrancheNames[trancheId];
 
    /*
     * We only ever add new entries to LWLockTrancheNames, so most lookups can
     * avoid taking the spinlock as long as the backend-local counter
     * (LocalLWLockCounter) is greater than the requested tranche ID.  Else,
     * we need to first update the backend-local counter with ShmemLock held
     * before attempting the lookup again.  In practice, the latter case is
     * probably rare.
     */
    if (trancheId >= LocalLWLockCounter)
    {
        SpinLockAcquire(ShmemLock);
        LocalLWLockCounter = *LWLockCounter;
        SpinLockRelease(ShmemLock);
 
        if (trancheId >= LocalLWLockCounter)
            elog(ERROR, "tranche %d is not registered", trancheId);
    }
 
    /*
     * It's an extension tranche, so look in LWLockTrancheNames.
     */
    trancheId -= LWTRANCHE_FIRST_USER_DEFINED;
 
    return LWLockTrancheNames[trancheId];
}
 
/*
 * Return an identifier for an LWLock based on the wait class and event.
 */
const char *
GetLWLockIdentifier(uint32 classId, uint16 eventId)
{
    Assert(classId == PG_WAIT_LWLOCK);
    /* The event IDs are just tranche numbers. */
    return GetLWTrancheName(eventId);
}
 
/*
 * Internal function that tries to atomically acquire the lwlock in the passed
 * in mode.
 *
 * This function will not block waiting for a lock to become free - that's the
 * caller's job.
 *
 * Returns true if the lock isn't free and we need to wait.
 */
static bool
LWLockAttemptLock(LWLock *lock, LWLockMode mode)
{
    uint32      old_state;
 
    Assert(mode == LW_EXCLUSIVE || mode == LW_SHARED);
 
    /*
     * Read once outside the loop, later iterations will get the newer value
     * via compare & exchange.
     */
    old_state = pg_atomic_read_u32(&lock->state);
 
    /* loop until we've determined whether we could acquire the lock or not */
    while (true)
    {
        uint32      desired_state;
        bool        lock_free;
 
        desired_state = old_state;
 
        if (mode == LW_EXCLUSIVE)
        {
            lock_free = (old_state & LW_LOCK_MASK) == 0;
            if (lock_free)
                desired_state += LW_VAL_EXCLUSIVE;
        }
        else
        {
            lock_free = (old_state & LW_VAL_EXCLUSIVE) == 0;
            if (lock_free)
                desired_state += LW_VAL_SHARED;
        }
 
        /*
         * Attempt to swap in the state we are expecting. If we didn't see
         * lock to be free, that's just the old value. If we saw it as free,
         * we'll attempt to mark it acquired. The reason that we always swap
         * in the value is that this doubles as a memory barrier. We could try
         * to be smarter and only swap in values if we saw the lock as free,
         * but benchmark haven't shown it as beneficial so far.
         *
         * Retry if the value changed since we last looked at it.
         */
        if (pg_atomic_compare_exchange_u32(&lock->state,
                                           &old_state, desired_state))
        {
            if (lock_free)
            {
                /* Great! Got the lock. */
#ifdef LOCK_DEBUG
                if (mode == LW_EXCLUSIVE)
                    lock->owner = MyProc;
#endif
                return false;
            }
            else
                return true;    /* somebody else has the lock */
        }
    }
    pg_unreachable();
}
 
/*
 * Lock the LWLock's wait list against concurrent activity.
 *
 * NB: even though the wait list is locked, non-conflicting lock operations
 * may still happen concurrently.
 *
 * Time spent holding mutex should be short!
 */
static void
LWLockWaitListLock(LWLock *lock)
{
    uint32      old_state;
#ifdef LWLOCK_STATS
    lwlock_stats *lwstats;
    uint32      delays = 0;
 
    lwstats = get_lwlock_stats_entry(lock);
#endif
 
    while (true)
    {
        /*
         * Always try once to acquire the lock directly, without setting up
         * the spin-delay infrastructure. The work necessary for that shows up
         * in profiles and is rarely necessary.
         */
        old_state = pg_atomic_fetch_or_u32(&lock->state, LW_FLAG_LOCKED);
        if (likely(!(old_state & LW_FLAG_LOCKED)))
            break;              /* got lock */
 
        /* and then spin without atomic operations until lock is released */
        {
            SpinDelayStatus delayStatus;
 
            init_local_spin_delay(&delayStatus);
 
            while (old_state & LW_FLAG_LOCKED)
            {
                perform_spin_delay(&delayStatus);
                old_state = pg_atomic_read_u32(&lock->state);
            }
#ifdef LWLOCK_STATS
            delays += delayStatus.delays;
#endif
            finish_spin_delay(&delayStatus);
        }
 
        /*
         * Retry. The lock might obviously already be re-acquired by the time
         * we're attempting to get it again.
         */
    }
 
#ifdef LWLOCK_STATS
    lwstats->spin_delay_count += delays;
#endif
}
 
/*
 * Unlock the LWLock's wait list.
 *
 * Note that it can be more efficient to manipulate flags and release the
 * locks in a single atomic operation.
 */
static void
LWLockWaitListUnlock(LWLock *lock)
{
    uint32      old_state PG_USED_FOR_ASSERTS_ONLY;
 
    old_state = pg_atomic_fetch_and_u32(&lock->state, ~LW_FLAG_LOCKED);
 
    Assert(old_state & LW_FLAG_LOCKED);
}
 
/*
 * Wakeup all the lockers that currently have a chance to acquire the lock.
 */
static void
LWLockWakeup(LWLock *lock)
{
    bool        new_wake_in_progress = false;
    bool        wokeup_somebody = false;
    proclist_head wakeup;
    proclist_mutable_iter iter;
 
    proclist_init(&wakeup);
 
    /* lock wait list while collecting backends to wake up */
    LWLockWaitListLock(lock);
 
    proclist_foreach_modify(iter, &lock->waiters, lwWaitLink)
    {
        PGPROC     *waiter = GetPGProcByNumber(iter.cur);
 
        if (wokeup_somebody && waiter->lwWaitMode == LW_EXCLUSIVE)
            continue;
 
        proclist_delete(&lock->waiters, iter.cur, lwWaitLink);
        proclist_push_tail(&wakeup, iter.cur, lwWaitLink);
 
        if (waiter->lwWaitMode != LW_WAIT_UNTIL_FREE)
        {
            /*
             * Prevent additional wakeups until retryer gets to run. Backends
             * that are just waiting for the lock to become free don't retry
             * automatically.
             */
            new_wake_in_progress = true;
 
            /*
             * Don't wakeup (further) exclusive locks.
             */
            wokeup_somebody = true;
        }
 
        /*
         * Signal that the process isn't on the wait list anymore. This allows
         * LWLockDequeueSelf() to remove itself of the waitlist with a
         * proclist_delete(), rather than having to check if it has been
         * removed from the list.
         */
        Assert(waiter->lwWaiting == LW_WS_WAITING);
        waiter->lwWaiting = LW_WS_PENDING_WAKEUP;
 
        /*
         * Once we've woken up an exclusive lock, there's no point in waking
         * up anybody else.
         */
        if (waiter->lwWaitMode == LW_EXCLUSIVE)
            break;
    }
 
    Assert(proclist_is_empty(&wakeup) || pg_atomic_read_u32(&lock->state) & LW_FLAG_HAS_WAITERS);
 
    /* unset required flags, and release lock, in one fell swoop */
    {
        uint32      old_state;
        uint32      desired_state;
 
        old_state = pg_atomic_read_u32(&lock->state);
        while (true)
        {
            desired_state = old_state;
 
            /* compute desired flags */
 
            if (new_wake_in_progress)
                desired_state |= LW_FLAG_WAKE_IN_PROGRESS;
            else
                desired_state &= ~LW_FLAG_WAKE_IN_PROGRESS;
 
            if (proclist_is_empty(&lock->waiters))
                desired_state &= ~LW_FLAG_HAS_WAITERS;
 
            desired_state &= ~LW_FLAG_LOCKED;   /* release lock */
 
            if (pg_atomic_compare_exchange_u32(&lock->state, &old_state,
                                               desired_state))
                break;
        }
    }
 
    /* Awaken any waiters I removed from the queue. */
    proclist_foreach_modify(iter, &wakeup, lwWaitLink)
    {
        PGPROC     *waiter = GetPGProcByNumber(iter.cur);
 
        LOG_LWDEBUG("LWLockRelease", lock, "release waiter");
        proclist_delete(&wakeup, iter.cur, lwWaitLink);
 
        /*
         * Guarantee that lwWaiting being unset only becomes visible once the
         * unlink from the link has completed. Otherwise the target backend
         * could be woken up for other reason and enqueue for a new lock - if
         * that happens before the list unlink happens, the list would end up
         * being corrupted.
         *
         * The barrier pairs with the LWLockWaitListLock() when enqueuing for
         * another lock.
         */
        pg_write_barrier();
        waiter->lwWaiting = LW_WS_NOT_WAITING;
        PGSemaphoreUnlock(waiter->sem);
    }
}
 
/*
 * Add ourselves to the end of the queue.
 *
 * NB: Mode can be LW_WAIT_UNTIL_FREE here!
 */
static void
LWLockQueueSelf(LWLock *lock, LWLockMode mode)
{
    /*
     * If we don't have a PGPROC structure, there's no way to wait. This
     * should never occur, since MyProc should only be null during shared
     * memory initialization.
     */
    if (MyProc == NULL)
        elog(PANIC, "cannot wait without a PGPROC structure");
 
    if (MyProc->lwWaiting != LW_WS_NOT_WAITING)
        elog(PANIC, "queueing for lock while waiting on another one");
 
    LWLockWaitListLock(lock);
 
    /* setting the flag is protected by the spinlock */
    pg_atomic_fetch_or_u32(&lock->state, LW_FLAG_HAS_WAITERS);
 
    MyProc->lwWaiting = LW_WS_WAITING;
    MyProc->lwWaitMode = mode;
 
    /* LW_WAIT_UNTIL_FREE waiters are always at the front of the queue */
    if (mode == LW_WAIT_UNTIL_FREE)
        proclist_push_head(&lock->waiters, MyProcNumber, lwWaitLink);
    else
        proclist_push_tail(&lock->waiters, MyProcNumber, lwWaitLink);
 
    /* Can release the mutex now */
    LWLockWaitListUnlock(lock);
 
#ifdef LOCK_DEBUG
    pg_atomic_fetch_add_u32(&lock->nwaiters, 1);
#endif
}
 
/*
 * Remove ourselves from the waitlist.
 *
 * This is used if we queued ourselves because we thought we needed to sleep
 * but, after further checking, we discovered that we don't actually need to
 * do so.
 */
static void
LWLockDequeueSelf(LWLock *lock)
{
    bool        on_waitlist;
 
#ifdef LWLOCK_STATS
    lwlock_stats *lwstats;
 
    lwstats = get_lwlock_stats_entry(lock);
 
    lwstats->dequeue_self_count++;
#endif
 
    LWLockWaitListLock(lock);
 
    /*
     * Remove ourselves from the waitlist, unless we've already been removed.
     * The removal happens with the wait list lock held, so there's no race in
     * this check.
     */
    on_waitlist = MyProc->lwWaiting == LW_WS_WAITING;
    if (on_waitlist)
        proclist_delete(&lock->waiters, MyProcNumber, lwWaitLink);
 
    if (proclist_is_empty(&lock->waiters) &&
        (pg_atomic_read_u32(&lock->state) & LW_FLAG_HAS_WAITERS) != 0)
    {
        pg_atomic_fetch_and_u32(&lock->state, ~LW_FLAG_HAS_WAITERS);
    }
 
    /* XXX: combine with fetch_and above? */
    LWLockWaitListUnlock(lock);
 
    /* clear waiting state again, nice for debugging */
    if (on_waitlist)
        MyProc->lwWaiting = LW_WS_NOT_WAITING;
    else
    {
        int         extraWaits = 0;
 
        /*
         * Somebody else dequeued us and has or will wake us up. Deal with the
         * superfluous absorption of a wakeup.
         */
 
        /*
         * Clear LW_FLAG_WAKE_IN_PROGRESS if somebody woke us before we
         * removed ourselves - they'll have set it.
         */
        pg_atomic_fetch_and_u32(&lock->state, ~LW_FLAG_WAKE_IN_PROGRESS);
 
        /*
         * Now wait for the scheduled wakeup, otherwise our ->lwWaiting would
         * get reset at some inconvenient point later. Most of the time this
         * will immediately return.
         */
        for (;;)
        {
            PGSemaphoreLock(MyProc->sem);
            if (MyProc->lwWaiting == LW_WS_NOT_WAITING)
                break;
            extraWaits++;
        }
 
        /*
         * Fix the process wait semaphore's count for any absorbed wakeups.
         */
        while (extraWaits-- > 0)
            PGSemaphoreUnlock(MyProc->sem);
    }
 
#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
}
 
/*
 * LWLockAcquire - acquire a lightweight lock in the specified mode
 *
 * If the lock is not available, sleep until it is.  Returns true if the lock
 * was available immediately, false if we had to sleep.
 *
 * Side effect: cancel/die interrupts are held off until lock release.
 */
bool
LWLockAcquire(LWLock *lock, LWLockMode mode)
{
    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_and_u32(&lock->state, ~LW_FLAG_WAKE_IN_PROGRESS);
 
#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;
}
 
/*
 * LWLockConditionalAcquire - acquire a lightweight lock in the specified mode
 *
 * If the lock is not available, return false with no side-effects.
 *
 * If successful, cancel/die interrupts are held off until lock release.
 */
bool
LWLockConditionalAcquire(LWLock *lock, LWLockMode mode)
{
    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;
}
 
/*
 * LWLockAcquireOrWait - Acquire lock, or wait until it's free
 *
 * The semantics of this function are a bit funky.  If the lock is currently
 * free, it is acquired in the given mode, and the function returns true.  If
 * the lock isn't immediately free, the function waits until it is released
 * and returns false, but does not acquire the lock.
 *
 * This is currently used for WALWriteLock: when a backend flushes the WAL,
 * holding WALWriteLock, it can flush the commit records of many other
 * backends as a side-effect.  Those other backends need to wait until the
 * flush finishes, but don't need to acquire the lock anymore.  They can just
 * wake up, observe that their records have already been flushed, and return.
 */
bool
LWLockAcquireOrWait(LWLock *lock, LWLockMode mode)
{
    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;
}
 
/*
 * Does the lwlock in its current state need to wait for the variable value to
 * change?
 *
 * If we don't need to wait, and it's because the value of the variable has
 * changed, store the current value in newval.
 *
 * *result is set to true if the lock was free, and false otherwise.
 */
static bool
LWLockConflictsWithVar(LWLock *lock, pg_atomic_uint64 *valptr, uint64 oldval,
                       uint64 *newval, bool *result)
{
    bool        mustwait;
    uint64      value;
 
    /*
     * Test first to see if it the slot is free right now.
     *
     * XXX: the unique caller of this routine, WaitXLogInsertionsToFinish()
     * via LWLockWaitForVar(), uses an implied barrier with a spinlock before
     * this, so we don't need a memory barrier here as far as the current
     * usage is concerned.  But that might not be safe in general.
     */
    mustwait = (pg_atomic_read_u32(&lock->state) & LW_VAL_EXCLUSIVE) != 0;
 
    if (!mustwait)
    {
        *result = true;
        return false;
    }
 
    *result = false;
 
    /*
     * Reading this value atomically is safe even on platforms where uint64
     * cannot be read without observing a torn value.
     */
    value = pg_atomic_read_u64(valptr);
 
    if (value != oldval)
    {
        mustwait = false;
        *newval = value;
    }
    else
    {
        mustwait = true;
    }
 
    return mustwait;
}
 
/*
 * LWLockWaitForVar - Wait until lock is free, or a variable is updated.
 *
 * If the lock is held and *valptr equals oldval, waits until the lock is
 * either freed, or the lock holder updates *valptr by calling
 * LWLockUpdateVar.  If the lock is free on exit (immediately or after
 * waiting), returns true.  If the lock is still held, but *valptr no longer
 * matches oldval, returns false and sets *newval to the current value in
 * *valptr.
 *
 * Note: this function ignores shared lock holders; if the lock is held
 * in shared mode, returns 'true'.
 *
 * Be aware that LWLockConflictsWithVar() does not include a memory barrier,
 * hence the caller of this function may want to rely on an explicit barrier or
 * an implied barrier via spinlock or LWLock to avoid memory ordering issues.
 */
bool
LWLockWaitForVar(LWLock *lock, pg_atomic_uint64 *valptr, uint64 oldval,
                 uint64 *newval)
{
    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);
 
        /*
         * Clear LW_FLAG_WAKE_IN_PROGRESS flag, to make sure we get woken up
         * as soon as the lock is released.
         */
        pg_atomic_fetch_and_u32(&lock->state, ~LW_FLAG_WAKE_IN_PROGRESS);
 
        /*
         * 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;
}
 
 
/*
 * LWLockUpdateVar - Update a variable and wake up waiters atomically
 *
 * Sets *valptr to 'val', and wakes up all processes waiting for us with
 * LWLockWaitForVar().  It first sets the value atomically and then wakes up
 * waiting processes so that any process calling LWLockWaitForVar() on the same
 * lock is guaranteed to see the new value, and act accordingly.
 *
 * The caller must be holding the lock in exclusive mode.
 */
void
LWLockUpdateVar(LWLock *lock, pg_atomic_uint64 *valptr, uint64 val)
{
    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);
    }
}
 
 
/*
 * LWLockRelease - release a previously acquired lock
 *
 * NB: This will leave lock->owner pointing to the current backend (if
 * LOCK_DEBUG is set). This is somewhat intentional, as it makes it easier to
 * debug cases of missing wakeups during lock release.
 */
void
LWLockRelease(LWLock *lock)
{
    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));
 
    /*
     * Check if we're still waiting for backends to get scheduled, if so,
     * don't wake them up again.
     */
    if ((oldstate & LW_FLAG_HAS_WAITERS) &&
        !(oldstate & LW_FLAG_WAKE_IN_PROGRESS) &&
        (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();
}
 
/*
 * LWLockReleaseClearVar - release a previously acquired lock, reset variable
 */
void
LWLockReleaseClearVar(LWLock *lock, pg_atomic_uint64 *valptr, uint64 val)
{
    /*
     * 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);
}
 
 
/*
 * LWLockReleaseAll - release all currently-held locks
 *
 * Used to clean up after ereport(ERROR). An important difference between this
 * function and retail LWLockRelease calls is that InterruptHoldoffCount is
 * unchanged by this operation.  This is necessary since InterruptHoldoffCount
 * has been set to an appropriate level earlier in error recovery. We could
 * decrement it below zero if we allow it to drop for each released lock!
 *
 * Note that this function must be safe to call even before the LWLock
 * subsystem has been initialized (e.g., during early startup failures).
 * In that case, num_held_lwlocks will be 0 and we do nothing.
 */
void
LWLockReleaseAll(void)
{
    while (num_held_lwlocks > 0)
    {
        HOLD_INTERRUPTS();      /* match the upcoming RESUME_INTERRUPTS */
 
        LWLockRelease(held_lwlocks[num_held_lwlocks - 1].lock);
    }
 
    Assert(num_held_lwlocks == 0);
}
 
 
/*
 * LWLockHeldByMe - test whether my process holds a lock in any mode
 *
 * This is meant as debug support only.
 */
bool
LWLockHeldByMe(LWLock *lock)
{
    int         i;
 
    for (i = 0; i < num_held_lwlocks; i++)
    {
        if (held_lwlocks[i].lock == lock)
            return true;
    }
    return false;
}
 
/*
 * LWLockAnyHeldByMe - test whether my process holds any of an array of locks
 *
 * This is meant as debug support only.
 */
bool
LWLockAnyHeldByMe(LWLock *lock, int nlocks, size_t stride)
{
    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;
}
 
/*
 * LWLockHeldByMeInMode - test whether my process holds a lock in given mode
 *
 * This is meant as debug support only.
 */
bool
LWLockHeldByMeInMode(LWLock *lock, LWLockMode mode)
{
    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;
}

Typedef Documentation

LWLockHandle

typedef struct LWLockHandle LWLockHandle

NamedLWLockTrancheRequest

typedef struct NamedLWLockTrancheRequest NamedLWLockTrancheRequest

Function Documentation

CreateLWLocks()

void CreateLWLocks

(

void

)

Definition at line 441 of file lwlock.c.

{
    if (!IsUnderPostmaster)
    {
        Size        spaceLocks = LWLockShmemSize();
        char       *ptr;
 
        /* Allocate space */
        ptr = (char *) ShmemAlloc(spaceLocks);
 
        /* Initialize the dynamic-allocation counter for tranches */
        LWLockCounter = (int *) ptr;
        *LWLockCounter = LWTRANCHE_FIRST_USER_DEFINED;
        ptr += MAXALIGN(sizeof(int));
 
        /* Initialize tranche names */
        LWLockTrancheNames = (char **) ptr;
        ptr += MAX_NAMED_TRANCHES * sizeof(char *);
        for (int i = 0; i < MAX_NAMED_TRANCHES; i++)
        {
            LWLockTrancheNames[i] = ptr;
            ptr += NAMEDATALEN;
        }
 
        /*
         * Move named tranche requests to shared memory.  This is done for the
         * benefit of EXEC_BACKEND builds, which otherwise wouldn't be able to
         * call GetNamedLWLockTranche() outside postmaster.
         */
        if (NamedLWLockTrancheRequests > 0)
        {
            /*
             * Save the pointer to the request array in postmaster's local
             * memory.  We'll need it if we ever need to re-initialize shared
             * memory after a crash.
             */
            LocalNamedLWLockTrancheRequestArray = NamedLWLockTrancheRequestArray;
 
            memcpy(ptr, NamedLWLockTrancheRequestArray,
                   NamedLWLockTrancheRequests * sizeof(NamedLWLockTrancheRequest));
            NamedLWLockTrancheRequestArray = (NamedLWLockTrancheRequest *) ptr;
            ptr += NamedLWLockTrancheRequests * sizeof(NamedLWLockTrancheRequest);
        }
 
        /* Ensure desired alignment of LWLock array */
        ptr += LWLOCK_PADDED_SIZE - ((uintptr_t) ptr) % LWLOCK_PADDED_SIZE;
        MainLWLockArray = (LWLockPadded *) ptr;
 
        /* Initialize all LWLocks */
        InitializeLWLocks();
    }
}

References fb(), i, InitializeLWLocks(), IsUnderPostmaster, LocalNamedLWLockTrancheRequestArray, LWLOCK_PADDED_SIZE, LWLockCounter, LWLockShmemSize(), LWLockTrancheNames, LWTRANCHE_FIRST_USER_DEFINED, MainLWLockArray, MAX_NAMED_TRANCHES, MAXALIGN, NAMEDATALEN, NamedLWLockTrancheRequestArray, NamedLWLockTrancheRequests, and ShmemAlloc().

Referenced by CreateOrAttachShmemStructs().

GetLWLockIdentifier()

const char * GetLWLockIdentifier	(	uint32	classId,
		uint16	eventId
	)

Definition at line 773 of file lwlock.c.

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

References Assert, fb(), GetLWTrancheName(), and PG_WAIT_LWLOCK.

Referenced by pgstat_get_wait_event().

GetLWTrancheName()

static const char * GetLWTrancheName ( uint16  trancheId )

static

Definition at line 737 of file lwlock.c.

{
    /* Built-in tranche or individual LWLock? */
    if (trancheId < LWTRANCHE_FIRST_USER_DEFINED)
        return BuiltinTrancheNames[trancheId];
 
    /*
     * We only ever add new entries to LWLockTrancheNames, so most lookups can
     * avoid taking the spinlock as long as the backend-local counter
     * (LocalLWLockCounter) is greater than the requested tranche ID.  Else,
     * we need to first update the backend-local counter with ShmemLock held
     * before attempting the lookup again.  In practice, the latter case is
     * probably rare.
     */
    if (trancheId >= LocalLWLockCounter)
    {
        SpinLockAcquire(ShmemLock);
        LocalLWLockCounter = *LWLockCounter;
        SpinLockRelease(ShmemLock);
 
        if (trancheId >= LocalLWLockCounter)
            elog(ERROR, "tranche %d is not registered", trancheId);
    }
 
    /*
     * It's an extension tranche, so look in LWLockTrancheNames.
     */
    trancheId -= LWTRANCHE_FIRST_USER_DEFINED;
 
    return LWLockTrancheNames[trancheId];
}

References BuiltinTrancheNames, elog, ERROR, fb(), LocalLWLockCounter, LWLockCounter, LWLockTrancheNames, LWTRANCHE_FIRST_USER_DEFINED, ShmemLock, SpinLockAcquire, and SpinLockRelease.

Referenced by GetLWLockIdentifier(), and LWLockInitialize().

GetNamedLWLockTranche()

LWLockPadded * GetNamedLWLockTranche

(

const char *

tranche_name

)

Definition at line 566 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, fb(), i, MainLWLockArray, NamedLWLockTrancheRequestArray, NamedLWLockTrancheRequests, NUM_FIXED_LWLOCKS, and NamedLWLockTrancheRequest::num_lwlocks.

Referenced by pgss_shmem_startup(), and test_lwlock_tranche_lookup().

InitializeLWLocks()

static void InitializeLWLocks ( void  )

static

Definition at line 498 of file lwlock.c.

{
    int         id;
    int         i;
    int         j;
    LWLockPadded *lock;
 
    /* Initialize all individual LWLocks in main array */
    for (id = 0, lock = MainLWLockArray; id < NUM_INDIVIDUAL_LWLOCKS; id++, lock++)
        LWLockInitialize(&lock->lock, id);
 
    /* Initialize buffer mapping LWLocks in main array */
    lock = MainLWLockArray + BUFFER_MAPPING_LWLOCK_OFFSET;
    for (id = 0; id < NUM_BUFFER_PARTITIONS; id++, lock++)
        LWLockInitialize(&lock->lock, LWTRANCHE_BUFFER_MAPPING);
 
    /* Initialize lmgrs' LWLocks in main array */
    lock = MainLWLockArray + LOCK_MANAGER_LWLOCK_OFFSET;
    for (id = 0; id < NUM_LOCK_PARTITIONS; id++, lock++)
        LWLockInitialize(&lock->lock, LWTRANCHE_LOCK_MANAGER);
 
    /* Initialize predicate lmgrs' LWLocks in main array */
    lock = MainLWLockArray + PREDICATELOCK_MANAGER_LWLOCK_OFFSET;
    for (id = 0; id < NUM_PREDICATELOCK_PARTITIONS; id++, lock++)
        LWLockInitialize(&lock->lock, LWTRANCHE_PREDICATE_LOCK_MANAGER);
 
    /*
     * Copy the info about any named tranches into shared memory (so that
     * other processes can see it), and initialize the requested LWLocks.
     */
    if (NamedLWLockTrancheRequests > 0)
    {
        lock = &MainLWLockArray[NUM_FIXED_LWLOCKS];
 
        for (i = 0; i < NamedLWLockTrancheRequests; i++)
        {
            NamedLWLockTrancheRequest *request;
            int         tranche;
 
            request = &NamedLWLockTrancheRequestArray[i];
            tranche = LWLockNewTrancheId(request->tranche_name);
 
            for (j = 0; j < request->num_lwlocks; j++, lock++)
                LWLockInitialize(&lock->lock, tranche);
        }
    }
}

References BUFFER_MAPPING_LWLOCK_OFFSET, fb(), i, j, LWLockPadded::lock, LOCK_MANAGER_LWLOCK_OFFSET, LWLockInitialize(), LWLockNewTrancheId(), MainLWLockArray, NamedLWLockTrancheRequestArray, NamedLWLockTrancheRequests, NUM_BUFFER_PARTITIONS, NUM_FIXED_LWLOCKS, NUM_LOCK_PARTITIONS, NUM_PREDICATELOCK_PARTITIONS, and PREDICATELOCK_MANAGER_LWLOCK_OFFSET.

Referenced by CreateLWLocks().

InitLWLockAccess()

void InitLWLockAccess

(

void

)

Definition at line 550 of file lwlock.c.

{
#ifdef LWLOCK_STATS
    init_lwlock_stats();
#endif
}

References fb().

Referenced by InitAuxiliaryProcess(), and InitProcess().

LWLockAcquire()

bool LWLockAcquire	(	LWLock *	lock,
		LWLockMode	mode
	)

Definition at line 1176 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_and_u32(&lock->state, ~LW_FLAG_WAKE_IN_PROGRESS);
 
#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, fb(), held_lwlocks, HOLD_INTERRUPTS, IsUnderPostmaster, LWLockHandle::lock, LOG_LWDEBUG, LW_EXCLUSIVE, LW_FLAG_WAKE_IN_PROGRESS, 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_and_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_parallel_done(), _bt_parallel_primscan_schedule(), _bt_parallel_release(), _bt_parallel_seize(), _bt_start_vacuum(), _bt_vacuum_cycleid(), abort_logical_decoding_activation(), AbsorbSyncRequests(), ActivateCommitTs(), addLSNWaiter(), AdvanceNextFullTransactionIdPastXid(), AdvanceOldestClogXid(), AdvanceOldestCommitTsXid(), AdvanceXLInsertBuffer(), alloc_object(), AlterSystemSetConfigFile(), ApplyLauncherMain(), apw_detach_shmem(), apw_dump_now(), apw_load_buffers(), AsyncNotifyFreezeXids(), asyncQueueAddEntries(), asyncQueueAdvanceTail(), asyncQueueReadAllNotifications(), asyncQueueUnregister(), AtAbort_Twophase(), AtEOXact_LogicalRepWorkers(), AtPrepare_PredicateLocks(), attach_internal(), autoprewarm_main(), autoprewarm_start_worker(), AutoVacLauncherMain(), AutoVacuumRequestWork(), AutoVacWorkerMain(), BackendPidGetProc(), BackendXidGetPid(), BecomeLockGroupLeader(), BecomeLockGroupMember(), BecomeRegisteredListener(), btparallelrescan(), BufferAlloc(), CancelDBBackends(), check_for_freed_segments(), CheckDeadLock(), CheckForSerializableConflictOut(), CheckLogicalSlotExists(), CheckPointPredicate(), CheckPointRelationMap(), CheckPointReplicationOrigin(), CheckPointReplicationSlots(), CheckPointTwoPhase(), CheckTableForSerializableConflictIn(), CheckTargetForConflictsIn(), choose_next_subplan_for_leader(), choose_next_subplan_for_worker(), CleanupInvalidationState(), ClearOldPredicateLocks(), ComputeXidHorizons(), consume_xids_shortcut(), copy_replication_slot(), CountDBBackends(), CountDBConnections(), CountOtherDBBackends(), CountUserBackends(), CreateCheckPoint(), CreateEndOfRecoveryRecord(), CreateInitDecodingContext(), CreatePredicateLock(), CreateRestartPoint(), DeactivateCommitTs(), DeleteChildTargetLocks(), DeleteLockTarget(), deleteLSNWaiter(), destroy_superblock(), DisableLogicalDecoding(), DisableLogicalDecodingIfNecessary(), do_autovacuum(), do_pg_backup_start(), do_pg_backup_stop(), do_start_worker(), DropAllPredicateLocksFromTable(), DropTableSpace(), dsa_allocate_extended(), dsa_dump(), dsa_free(), dsa_get_total_size(), dsa_get_total_size_from_handle(), 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(), EnableLogicalDecoding(), ensure_active_superblock(), entry_reset(), ExecParallelHashMergeCounters(), ExecParallelHashPopChunkQueue(), ExecParallelHashTupleAlloc(), ExecParallelHashTuplePrealloc(), ExpireAllKnownAssignedTransactionIds(), ExpireOldKnownAssignedTransactionIds(), ExpireTreeKnownAssignedTransactionIds(), ExtendBufferedRelShared(), ExtendCLOG(), ExtendCommitTs(), ExtendMultiXactMember(), ExtendMultiXactOffset(), ExtendSUBTRANS(), FastPathGetRelationLockEntry(), FastPathTransferRelationLocks(), FindAndDropRelationBuffers(), FindDeletedTupleInLocalRel(), FinishPreparedTransaction(), ForceTransactionIdLimitUpdate(), ForwardSyncRequest(), FreeWorkerInfo(), get_local_synced_slots(), get_val_in_shmem(), get_xid_status(), GetBackgroundWorkerPid(), GetBackgroundWorkerTypeByPid(), GetBlockerStatusData(), GetConflictingVirtualXIDs(), GetCurrentVirtualXIDs(), GetLastImportantRecPtr(), GetLastSegSwitchData(), GetLatestCommitTsData(), GetLeaderApplyWorkerPid(), GetLockConflicts(), GetLockStatusData(), GetMultiXactIdMembers(), GetMultiXactInfo(), GetNewMultiXactId(), GetNewObjectId(), GetNewTransactionId(), GetOldestActiveTransactionId(), GetOldestMultiXactId(), GetOldestRestartPoint(), GetOldestSafeDecodingTransactionId(), GetOldestUnsummarizedLSN(), GetPredicateLockStatusData(), GetPreparedTransactionList(), GetRunningTransactionData(), GetRunningTransactionLocks(), GetSafeSnapshot(), GetSafeSnapshotBlockingPids(), GetSerializableTransactionSnapshotInt(), GetSnapshotData(), GetStrictOldestNonRemovableTransactionId(), GetVirtualXIDsDelayingChkpt(), GetWaitEventCustomIdentifier(), GetWaitEventCustomNames(), GetWalSummarizerState(), HaveVirtualXIDsDelayingChkpt(), init_conflict_slot_xmin(), init_dsm_registry(), initGlobalChannelTable(), InitWalSender(), injection_shmem_startup(), InjectionPointAttach(), InjectionPointDetach(), InjectionPointList(), InstallXLogFileSegment(), InvalidateBuffer(), InvalidateObsoleteReplicationSlots(), InvalidatePossiblyObsoleteSlot(), InvalidateVictimBuffer(), IoWorkerMain(), IsInstallXLogFileSegmentActive(), IsLogicalDecodingEnabled(), IsXLogLogicalInfoEnabled(), KnownAssignedXidsCompress(), KnownAssignedXidsReset(), lock_twophase_recover(), LockAcquireExtended(), LockErrorCleanup(), LockGXact(), LockHasWaiters(), LockRefindAndRelease(), LockRelease(), LockReleaseAll(), LockWaiterCount(), logicalrep_launcher_attach_dshmem(), logicalrep_pa_worker_stop(), logicalrep_reset_seqsync_start_time(), logicalrep_worker_attach(), logicalrep_worker_detach(), logicalrep_worker_launch(), logicalrep_worker_stop(), logicalrep_worker_stop_internal(), logicalrep_worker_wakeup(), logicalrep_workers_find(), LookupGXact(), LookupGXactBySubid(), MarkAsPrepared(), MarkAsPreparing(), 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_get_shmem_allocations_numa(), pg_notification_queue_usage(), pg_show_replication_origin_status(), pg_stat_get_subscription(), pg_stat_statements_internal(), pg_xact_status(), pgaio_worker_die(), pgaio_worker_register(), pgaio_worker_submit_internal(), 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_io_flush_cb(), 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_cb(), pgstat_slru_snapshot_cb(), pgstat_wal_flush_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(), ProcessSequencesForSync(), ProcessSyncingTablesForApply(), ProcKill(), ProcNumberGetTransactionIds(), ProcSleep(), ReachedEndOfBackup(), read_relmap_file(), ReadMultiXactIdRange(), ReadNextFullTransactionId(), ReadNextMultiXactId(), ReadReplicationSlot(), RecordNewMultiXact(), RecoverPreparedTransactions(), RegisterDynamicBackgroundWorker(), RegisterPredicateLockingXid(), RelationCacheInitFilePreInvalidate(), RelationMapCopy(), RelationMapFinishBootstrap(), ReleaseOneSerializableXact(), ReleasePredicateLocks(), relmap_redo(), RemoveScratchTarget(), ReplicationSlotAcquire(), ReplicationSlotCleanup(), ReplicationSlotCreate(), ReplicationSlotDropPtr(), ReplicationSlotName(), ReplicationSlotRelease(), ReplicationSlotReserveWal(), ReplicationSlotsComputeLogicalRestartLSN(), ReplicationSlotsComputeRequiredLSN(), ReplicationSlotsComputeRequiredXmin(), ReplicationSlotsCountDBSlots(), ReplicationSlotsDropDBSlots(), replorigin_advance(), replorigin_get_progress(), replorigin_session_advance(), replorigin_session_get_progress(), replorigin_session_reset_internal(), replorigin_session_setup(), replorigin_state_clear(), RequestDisableLogicalDecoding(), ResetInstallXLogFileSegmentActive(), resize(), RestoreScratchTarget(), restoreTwoPhaseData(), SaveSlotToPath(), SearchNamedReplicationSlot(), SerialAdd(), SerialGetMinConflictCommitSeqNo(), SerialInit(), SerialSetActiveSerXmin(), set_indexsafe_procflags(), set_val_in_shmem(), SetCommitTsLimit(), SetInstallXLogFileSegmentActive(), SetMultiXactIdLimit(), SetNextObjectId(), SetOldestOffset(), SetTransactionIdLimit(), SetXidCommitTsInPage(), SharedInvalBackendInit(), ShmemInitStruct(), SICleanupQueue(), SIGetDataEntries(), SignalBackends(), SignalVirtualTransaction(), SIInsertDataEntries(), SimpleLruReadPage(), SimpleLruReadPage_ReadOnly(), SimpleLruTruncate(), SimpleLruWaitIO(), SimpleLruWriteAll(), SimpleLruZeroAndWritePage(), SlruDeleteSegment(), SlruInternalWritePage(), SnapBuildInitialSnapshot(), ss_get_location(), StandbyRecoverPreparedTransactions(), StandbySlotsHaveCaughtup(), StartupDecodingContext(), StartupSUBTRANS(), StartupXLOG(), sts_parallel_scan_next(), SubTransSetParent(), SummarizeOldestCommittedSxact(), SummarizeWAL(), SwitchIntoArchiveRecovery(), synchronize_one_slot(), SyncRepCancelWait(), SyncRepCleanupAtProcExit(), SyncRepReleaseWaiters(), SyncRepUpdateSyncStandbysDefined(), SyncRepWaitForLSN(), TablespaceCreateDbspace(), tbm_shared_iterate(), TerminateBackgroundWorker(), TerminateBackgroundWorkersForDatabase(), TerminateOtherDBBackends(), test_aio_shmem_startup(), test_custom_stats_fixed_reset_all_cb(), test_custom_stats_fixed_snapshot_cb(), test_custom_stats_fixed_update(), test_slru_page_exists(), test_slru_page_read(), test_slru_page_write(), TransactionGroupUpdateXidStatus(), TransactionIdGetCommitTsData(), TransactionIdIsInProgress(), TransactionIdSetPageStatus(), TransactionTreeSetCommitTsData(), TransferPredicateLocksToNewTarget(), TrimCLOG(), TrimMultiXact(), TruncateMultiXact(), TwoPhaseGetGXact(), TwoPhaseGetOldestXidInCommit(), TwoPhaseGetXidByVirtualXID(), update_cached_xid_range(), update_synced_slots_inactive_since(), UpdateLogicalDecodingStatusEndOfRecovery(), UpdateMinRecoveryPoint(), vac_truncate_clog(), vacuum_rel(), VacuumUpdateCosts(), VirtualXactLock(), VirtualXactLockTableCleanup(), VirtualXactLockTableInsert(), wait_for_table_state_change(), wait_for_worker_state_change(), WaitEventCustomNew(), WaitForReplicationWorkerAttach(), WaitForWalSummarization(), wakeupWaiters(), WakeupWalSummarizer(), WALInsertLockAcquire(), WALInsertLockAcquireExclusive(), WalSummarizerMain(), WalSummarizerShutdown(), write_relcache_init_file(), xact_redo(), XidCacheRemoveRunningXids(), xlog_redo(), XLogBackgroundFlush(), and XLogReportParameters().

LWLockAcquireOrWait()

bool LWLockAcquireOrWait	(	LWLock *	lock,
		LWLockMode	mode
	)

Definition at line 1404 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, fb(), 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 1929 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 fb(), held_lwlocks, i, and num_held_lwlocks.

LWLockAttemptLock()

static bool LWLockAttemptLock ( LWLock *  lock, LWLockMode  mode  )

static

Definition at line 790 of file lwlock.c.

{
    uint32      old_state;
 
    Assert(mode == LW_EXCLUSIVE || mode == LW_SHARED);
 
    /*
     * Read once outside the loop, later iterations will get the newer value
     * via compare & exchange.
     */
    old_state = pg_atomic_read_u32(&lock->state);
 
    /* loop until we've determined whether we could acquire the lock or not */
    while (true)
    {
        uint32      desired_state;
        bool        lock_free;
 
        desired_state = old_state;
 
        if (mode == LW_EXCLUSIVE)
        {
            lock_free = (old_state & LW_LOCK_MASK) == 0;
            if (lock_free)
                desired_state += LW_VAL_EXCLUSIVE;
        }
        else
        {
            lock_free = (old_state & LW_VAL_EXCLUSIVE) == 0;
            if (lock_free)
                desired_state += LW_VAL_SHARED;
        }
 
        /*
         * Attempt to swap in the state we are expecting. If we didn't see
         * lock to be free, that's just the old value. If we saw it as free,
         * we'll attempt to mark it acquired. The reason that we always swap
         * in the value is that this doubles as a memory barrier. We could try
         * to be smarter and only swap in values if we saw the lock as free,
         * but benchmark haven't shown it as beneficial so far.
         *
         * Retry if the value changed since we last looked at it.
         */
        if (pg_atomic_compare_exchange_u32(&lock->state,
                                           &old_state, desired_state))
        {
            if (lock_free)
            {
                /* Great! Got the lock. */
#ifdef LOCK_DEBUG
                if (mode == LW_EXCLUSIVE)
                    lock->owner = MyProc;
#endif
                return false;
            }
            else
                return true;    /* somebody else has the lock */
        }
    }
    pg_unreachable();
}

References Assert, fb(), LW_EXCLUSIVE, LW_LOCK_MASK, LW_SHARED, LW_VAL_EXCLUSIVE, LW_VAL_SHARED, mode, MyProc, pg_atomic_compare_exchange_u32(), pg_atomic_read_u32(), pg_unreachable, and LWLock::state.

Referenced by LWLockAcquire(), LWLockAcquireOrWait(), and LWLockConditionalAcquire().

LWLockConditionalAcquire()

bool LWLockConditionalAcquire	(	LWLock *	lock,
		LWLockMode	mode
	)

Definition at line 1347 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, fb(), 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 pgstat_io_flush_cb(), pgstat_lock_entry(), pgstat_lock_entry_shared(), pgstat_slru_flush_cb(), pgstat_wal_flush_cb(), ProcArrayEndTransaction(), SimpleLruWaitIO(), ss_report_location(), TransactionIdSetPageStatus(), and XLogNeedsFlush().

LWLockConflictsWithVar()

static bool LWLockConflictsWithVar ( LWLock *  lock, pg_atomic_uint64 *  valptr, uint64  oldval, uint64 *  newval, bool *  result  )

static

Definition at line 1531 of file lwlock.c.

{
    bool        mustwait;
    uint64      value;
 
    /*
     * Test first to see if it the slot is free right now.
     *
     * XXX: the unique caller of this routine, WaitXLogInsertionsToFinish()
     * via LWLockWaitForVar(), uses an implied barrier with a spinlock before
     * this, so we don't need a memory barrier here as far as the current
     * usage is concerned.  But that might not be safe in general.
     */
    mustwait = (pg_atomic_read_u32(&lock->state) & LW_VAL_EXCLUSIVE) != 0;
 
    if (!mustwait)
    {
        *result = true;
        return false;
    }
 
    *result = false;
 
    /*
     * Reading this value atomically is safe even on platforms where uint64
     * cannot be read without observing a torn value.
     */
    value = pg_atomic_read_u64(valptr);
 
    if (value != oldval)
    {
        mustwait = false;
        *newval = value;
    }
    else
    {
        mustwait = true;
    }
 
    return mustwait;
}

References fb(), LW_VAL_EXCLUSIVE, newval, pg_atomic_read_u32(), pg_atomic_read_u64(), LWLock::state, and value.

Referenced by LWLockWaitForVar().

LWLockDequeueSelf()

static void LWLockDequeueSelf ( LWLock *  lock )

static

Definition at line 1087 of file lwlock.c.

{
    bool        on_waitlist;
 
#ifdef LWLOCK_STATS
    lwlock_stats *lwstats;
 
    lwstats = get_lwlock_stats_entry(lock);
 
    lwstats->dequeue_self_count++;
#endif
 
    LWLockWaitListLock(lock);
 
    /*
     * Remove ourselves from the waitlist, unless we've already been removed.
     * The removal happens with the wait list lock held, so there's no race in
     * this check.
     */
    on_waitlist = MyProc->lwWaiting == LW_WS_WAITING;
    if (on_waitlist)
        proclist_delete(&lock->waiters, MyProcNumber, lwWaitLink);
 
    if (proclist_is_empty(&lock->waiters) &&
        (pg_atomic_read_u32(&lock->state) & LW_FLAG_HAS_WAITERS) != 0)
    {
        pg_atomic_fetch_and_u32(&lock->state, ~LW_FLAG_HAS_WAITERS);
    }
 
    /* XXX: combine with fetch_and above? */
    LWLockWaitListUnlock(lock);
 
    /* clear waiting state again, nice for debugging */
    if (on_waitlist)
        MyProc->lwWaiting = LW_WS_NOT_WAITING;
    else
    {
        int         extraWaits = 0;
 
        /*
         * Somebody else dequeued us and has or will wake us up. Deal with the
         * superfluous absorption of a wakeup.
         */
 
        /*
         * Clear LW_FLAG_WAKE_IN_PROGRESS if somebody woke us before we
         * removed ourselves - they'll have set it.
         */
        pg_atomic_fetch_and_u32(&lock->state, ~LW_FLAG_WAKE_IN_PROGRESS);
 
        /*
         * Now wait for the scheduled wakeup, otherwise our ->lwWaiting would
         * get reset at some inconvenient point later. Most of the time this
         * will immediately return.
         */
        for (;;)
        {
            PGSemaphoreLock(MyProc->sem);
            if (MyProc->lwWaiting == LW_WS_NOT_WAITING)
                break;
            extraWaits++;
        }
 
        /*
         * Fix the process wait semaphore's count for any absorbed wakeups.
         */
        while (extraWaits-- > 0)
            PGSemaphoreUnlock(MyProc->sem);
    }
 
#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
}

References Assert, fb(), LW_FLAG_HAS_WAITERS, LW_FLAG_WAKE_IN_PROGRESS, LW_WS_NOT_WAITING, LW_WS_WAITING, LWLockWaitListLock(), LWLockWaitListUnlock(), PGPROC::lwWaiting, MAX_BACKENDS, MyProc, MyProcNumber, pg_atomic_fetch_and_u32(), pg_atomic_fetch_sub_u32(), pg_atomic_read_u32(), PG_USED_FOR_ASSERTS_ONLY, PGSemaphoreLock(), PGSemaphoreUnlock(), proclist_delete, proclist_is_empty(), PGPROC::sem, LWLock::state, and LWLock::waiters.

Referenced by LWLockAcquire(), LWLockAcquireOrWait(), and LWLockWaitForVar().

LWLockHeldByMe()

bool LWLockHeldByMe

(

LWLock *

lock

)

Definition at line 1911 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(), get_best_segment(), GetLockHoldersAndWaiters(), 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(), OnConflict_CheckForSerializationFailure(), ProcArrayEndTransaction(), ProcArraySetReplicationSlotXmin(), ProcSleep(), ReleaseOneSerializableXact(), RemoveScratchTarget(), RemoveTargetIfNoLongerUsed(), resize(), RestoreScratchTarget(), SetNewSxactGlobalXmin(), SlruSelectLRUPage(), test_slru_page_readonly(), TransactionIdInRecentPast(), TwoPhaseGetGXact(), and VacuumUpdateCosts().

LWLockHeldByMeInMode()

bool LWLockHeldByMeInMode	(	LWLock *	lock,
		LWLockMode	mode
	)

Definition at line 1955 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 DeleteLockTarget(), dshash_delete_current(), dshash_delete_entry(), dshash_seq_next(), InvalidatePossiblyObsoleteSlot(), JoinWaitQueue(), logicalrep_worker_cleanup(), logicalrep_worker_stop_internal(), MarkAsPreparingGuts(), pgstat_create_replslot(), pgstat_drop_replslot(), PrepareRedoAdd(), PrepareRedoRemoveFull(), ProcArrayEndTransactionInternal(), ProcessTwoPhaseBuffer(), RemoveGXact(), ReplicationSlotsComputeRequiredXmin(), SimpleLruReadPage(), SimpleLruZeroPage(), SlruInternalWritePage(), SyncRepWakeQueue(), TransactionIdSetPageStatusInternal(), TransactionIdSetStatusBit(), TransferPredicateLocksToNewTarget(), and write_relmap_file().

LWLockInitialize()

void LWLockInitialize	(	LWLock *	lock,
		int	tranche_id
	)

Definition at line 698 of file lwlock.c.

{
    /* verify the tranche_id is valid */
    (void) GetLWTrancheName(tranche_id);
 
    pg_atomic_init_u32(&lock->state, 0);
#ifdef LOCK_DEBUG
    pg_atomic_init_u32(&lock->nwaiters, 0);
#endif
    lock->tranche = tranche_id;
    proclist_init(&lock->waiters);
}

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

Referenced by apw_init_state(), btinitparallelscan(), create_internal(), dshash_create(), ExecAppendInitializeDSM(), ExecHashJoinInitializeDSM(), init_tdr_dsm(), InitializeLWLocks(), InitProcGlobal(), pgstat_archiver_init_shmem_cb(), pgstat_bgwriter_init_shmem_cb(), pgstat_checkpointer_init_shmem_cb(), pgstat_init_entry(), pgstat_io_init_shmem_cb(), pgstat_slru_init_shmem_cb(), pgstat_wal_init_shmem_cb(), PredicateLockShmemInit(), ReplicationOriginShmemInit(), ReplicationSlotsShmemInit(), SimpleLruInit(), sts_initialize(), tbm_prepare_shared_iterate(), test_custom_stats_fixed_init_shmem_cb(), test_lwlock_initialize(), and XLOGShmemInit().

LWLockNewTrancheId()

int LWLockNewTrancheId

(

const char *

name

)

Definition at line 596 of file lwlock.c.

{
    int         result;
 
    if (!name)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_NAME),
                 errmsg("tranche name cannot be NULL")));
 
    if (strlen(name) >= NAMEDATALEN)
        ereport(ERROR,
                (errcode(ERRCODE_NAME_TOO_LONG),
                 errmsg("tranche name too long"),
                 errdetail("LWLock tranche names must be no longer than %d bytes.",
                           NAMEDATALEN - 1)));
 
    /*
     * We use the ShmemLock spinlock to protect LWLockCounter and
     * LWLockTrancheNames.
     */
    SpinLockAcquire(ShmemLock);
 
    if (*LWLockCounter - LWTRANCHE_FIRST_USER_DEFINED >= MAX_NAMED_TRANCHES)
    {
        SpinLockRelease(ShmemLock);
        ereport(ERROR,
                (errmsg("maximum number of tranches already registered"),
                 errdetail("No more than %d tranches may be registered.",
                           MAX_NAMED_TRANCHES)));
    }
 
    result = (*LWLockCounter)++;
    LocalLWLockCounter = *LWLockCounter;
    strlcpy(LWLockTrancheNames[result - LWTRANCHE_FIRST_USER_DEFINED], name, NAMEDATALEN);
 
    SpinLockRelease(ShmemLock);
 
    return result;
}

References ereport, errcode(), errdetail(), errmsg(), ERROR, fb(), LocalLWLockCounter, LWLockCounter, LWLockTrancheNames, LWTRANCHE_FIRST_USER_DEFINED, MAX_NAMED_TRANCHES, name, NAMEDATALEN, ShmemLock, SpinLockAcquire, SpinLockRelease, and strlcpy().

Referenced by apw_init_state(), GetNamedDSA(), GetNamedDSHash(), init_tdr_dsm(), init_tranche(), InitializeLWLocks(), test_basic(), test_create(), test_empty(), test_lwlock_tranche_creation(), test_lwlock_tranches(), test_random(), and test_slru_shmem_startup().

LWLockQueueSelf()

static void LWLockQueueSelf ( LWLock *  lock, LWLockMode  mode  )

static

Definition at line 1044 of file lwlock.c.

{
    /*
     * If we don't have a PGPROC structure, there's no way to wait. This
     * should never occur, since MyProc should only be null during shared
     * memory initialization.
     */
    if (MyProc == NULL)
        elog(PANIC, "cannot wait without a PGPROC structure");
 
    if (MyProc->lwWaiting != LW_WS_NOT_WAITING)
        elog(PANIC, "queueing for lock while waiting on another one");
 
    LWLockWaitListLock(lock);
 
    /* setting the flag is protected by the spinlock */
    pg_atomic_fetch_or_u32(&lock->state, LW_FLAG_HAS_WAITERS);
 
    MyProc->lwWaiting = LW_WS_WAITING;
    MyProc->lwWaitMode = mode;
 
    /* LW_WAIT_UNTIL_FREE waiters are always at the front of the queue */
    if (mode == LW_WAIT_UNTIL_FREE)
        proclist_push_head(&lock->waiters, MyProcNumber, lwWaitLink);
    else
        proclist_push_tail(&lock->waiters, MyProcNumber, lwWaitLink);
 
    /* Can release the mutex now */
    LWLockWaitListUnlock(lock);
 
#ifdef LOCK_DEBUG
    pg_atomic_fetch_add_u32(&lock->nwaiters, 1);
#endif
}

References elog, fb(), LW_FLAG_HAS_WAITERS, LW_WAIT_UNTIL_FREE, LW_WS_NOT_WAITING, LW_WS_WAITING, LWLockWaitListLock(), LWLockWaitListUnlock(), PGPROC::lwWaiting, PGPROC::lwWaitMode, mode, MyProc, MyProcNumber, PANIC, pg_atomic_fetch_add_u32(), pg_atomic_fetch_or_u32(), proclist_push_head, proclist_push_tail, LWLock::state, and LWLock::waiters.

Referenced by LWLockAcquire(), LWLockAcquireOrWait(), and LWLockWaitForVar().

LWLockRelease()

void LWLockRelease

(

LWLock *

lock

)

Definition at line 1793 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));
 
    /*
     * Check if we're still waiting for backends to get scheduled, if so,
     * don't wake them up again.
     */
    if ((oldstate & LW_FLAG_HAS_WAITERS) &&
        !(oldstate & LW_FLAG_WAKE_IN_PROGRESS) &&
        (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, fb(), held_lwlocks, i, LOG_LWDEBUG, LW_EXCLUSIVE, LW_FLAG_HAS_WAITERS, LW_FLAG_WAKE_IN_PROGRESS, 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_parallel_done(), _bt_parallel_primscan_schedule(), _bt_parallel_release(), _bt_parallel_seize(), _bt_start_vacuum(), _bt_vacuum_cycleid(), abort_logical_decoding_activation(), AbsorbSyncRequests(), ActivateCommitTs(), addLSNWaiter(), AdvanceNextFullTransactionIdPastXid(), AdvanceOldestClogXid(), AdvanceOldestCommitTsXid(), AdvanceXLInsertBuffer(), alloc_object(), AlterSystemSetConfigFile(), ApplyLauncherMain(), apw_detach_shmem(), apw_dump_now(), apw_load_buffers(), AsyncNotifyFreezeXids(), asyncQueueAddEntries(), asyncQueueAdvanceTail(), asyncQueueProcessPageEntries(), asyncQueueReadAllNotifications(), asyncQueueUnregister(), AtAbort_Twophase(), AtEOXact_LogicalRepWorkers(), AtPrepare_PredicateLocks(), attach_internal(), autoprewarm_main(), autoprewarm_start_worker(), AutoVacLauncherMain(), AutoVacuumRequestWork(), AutoVacWorkerMain(), BackendPidGetProc(), BackendXidGetPid(), BecomeLockGroupLeader(), BecomeLockGroupMember(), BecomeRegisteredListener(), btparallelrescan(), BufferAlloc(), CancelDBBackends(), check_for_freed_segments(), CheckDeadLock(), CheckForSerializableConflictOut(), CheckLogicalSlotExists(), CheckPointPredicate(), CheckPointRelationMap(), CheckPointReplicationOrigin(), CheckPointReplicationSlots(), CheckPointTwoPhase(), CheckTableForSerializableConflictIn(), CheckTargetForConflictsIn(), choose_next_subplan_for_leader(), choose_next_subplan_for_worker(), CleanupInvalidationState(), ClearOldPredicateLocks(), ComputeXidHorizons(), consume_xids_shortcut(), copy_replication_slot(), CountDBBackends(), CountDBConnections(), CountOtherDBBackends(), CountUserBackends(), CreateCheckPoint(), CreateEndOfRecoveryRecord(), CreateInitDecodingContext(), CreatePredicateLock(), CreateRestartPoint(), DeactivateCommitTs(), DeleteChildTargetLocks(), DeleteLockTarget(), deleteLSNWaiter(), destroy_superblock(), DisableLogicalDecoding(), DisableLogicalDecodingIfNecessary(), do_autovacuum(), do_pg_backup_start(), do_pg_backup_stop(), do_start_worker(), DropAllPredicateLocksFromTable(), DropTableSpace(), dsa_allocate_extended(), dsa_dump(), dsa_free(), dsa_get_total_size(), dsa_get_total_size_from_handle(), 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(), EnableLogicalDecoding(), ensure_active_superblock(), entry_reset(), ExecParallelHashMergeCounters(), ExecParallelHashPopChunkQueue(), ExecParallelHashTupleAlloc(), ExecParallelHashTuplePrealloc(), ExpireAllKnownAssignedTransactionIds(), ExpireOldKnownAssignedTransactionIds(), ExpireTreeKnownAssignedTransactionIds(), ExtendBufferedRelShared(), ExtendCLOG(), ExtendCommitTs(), ExtendMultiXactMember(), ExtendMultiXactOffset(), ExtendSUBTRANS(), FastPathGetRelationLockEntry(), FastPathTransferRelationLocks(), find_multixact_start(), FindAndDropRelationBuffers(), FindDeletedTupleInLocalRel(), FinishPreparedTransaction(), ForceTransactionIdLimitUpdate(), ForwardSyncRequest(), FreeWorkerInfo(), get_local_synced_slots(), get_val_in_shmem(), get_xid_status(), GetBackgroundWorkerPid(), GetBackgroundWorkerTypeByPid(), GetBlockerStatusData(), GetConflictingVirtualXIDs(), GetCurrentVirtualXIDs(), GetLastImportantRecPtr(), GetLastSegSwitchData(), GetLatestCommitTsData(), GetLeaderApplyWorkerPid(), GetLockConflicts(), GetLockStatusData(), GetMultiXactIdMembers(), GetMultiXactInfo(), GetNewMultiXactId(), GetNewObjectId(), GetNewTransactionId(), GetOldestActiveTransactionId(), GetOldestMultiXactId(), GetOldestRestartPoint(), GetOldestSafeDecodingTransactionId(), GetOldestUnsummarizedLSN(), GetPredicateLockStatusData(), GetPreparedTransactionList(), GetRunningTransactionLocks(), GetSafeSnapshot(), GetSafeSnapshotBlockingPids(), GetSerializableTransactionSnapshotInt(), GetSnapshotData(), GetStrictOldestNonRemovableTransactionId(), GetVirtualXIDsDelayingChkpt(), GetWaitEventCustomIdentifier(), GetWaitEventCustomNames(), GetWalSummarizerState(), HaveVirtualXIDsDelayingChkpt(), init_conflict_slot_xmin(), init_dsm_registry(), initGlobalChannelTable(), InitWalSender(), injection_shmem_startup(), InjectionPointAttach(), InjectionPointDetach(), InjectionPointList(), InstallXLogFileSegment(), InvalidateBuffer(), InvalidateObsoleteReplicationSlots(), InvalidatePossiblyObsoleteSlot(), InvalidateVictimBuffer(), IoWorkerMain(), IsInstallXLogFileSegmentActive(), IsLogicalDecodingEnabled(), IsXLogLogicalInfoEnabled(), KnownAssignedXidsCompress(), KnownAssignedXidsReset(), lock_twophase_recover(), LockAcquireExtended(), LockErrorCleanup(), LockGXact(), LockHasWaiters(), LockRefindAndRelease(), LockRelease(), LockReleaseAll(), LockWaiterCount(), logicalrep_launcher_attach_dshmem(), logicalrep_pa_worker_stop(), logicalrep_reset_seqsync_start_time(), logicalrep_worker_attach(), logicalrep_worker_detach(), logicalrep_worker_launch(), logicalrep_worker_stop(), logicalrep_worker_stop_internal(), logicalrep_worker_wakeup(), logicalrep_workers_find(), LogStandbySnapshot(), LookupGXact(), LookupGXactBySubid(), LWLockReleaseAll(), LWLockReleaseClearVar(), MarkAsPrepared(), MarkAsPreparing(), 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_get_shmem_allocations_numa(), pg_notification_queue_usage(), pg_show_replication_origin_status(), pg_stat_get_subscription(), pg_stat_statements_internal(), pg_xact_status(), pgaio_worker_die(), pgaio_worker_register(), pgaio_worker_submit_internal(), 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_io_flush_cb(), pgstat_io_reset_all_cb(), pgstat_io_snapshot_cb(), pgstat_reset_matching_entries(), pgstat_reset_replslot(), pgstat_reset_slru_counter_internal(), pgstat_slru_flush_cb(), pgstat_slru_snapshot_cb(), pgstat_unlock_entry(), pgstat_wal_flush_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(), ProcessSequencesForSync(), ProcessSyncingTablesForApply(), ProcKill(), ProcNumberGetTransactionIds(), ProcSleep(), ReachedEndOfBackup(), read_relmap_file(), ReadMultiXactIdRange(), ReadNextFullTransactionId(), ReadNextMultiXactId(), ReadReplicationSlot(), RecordNewMultiXact(), RecoverPreparedTransactions(), RegisterDynamicBackgroundWorker(), RegisterPredicateLockingXid(), RelationCacheInitFilePostInvalidate(), RelationMapCopy(), RelationMapFinishBootstrap(), ReleaseOneSerializableXact(), ReleasePredicateLocks(), relmap_redo(), RemoveScratchTarget(), ReplicationSlotAcquire(), ReplicationSlotCleanup(), ReplicationSlotCreate(), ReplicationSlotDropPtr(), ReplicationSlotName(), ReplicationSlotRelease(), ReplicationSlotReserveWal(), ReplicationSlotsComputeLogicalRestartLSN(), ReplicationSlotsComputeRequiredLSN(), ReplicationSlotsComputeRequiredXmin(), ReplicationSlotsCountDBSlots(), ReplicationSlotsDropDBSlots(), replorigin_advance(), replorigin_get_progress(), replorigin_session_advance(), replorigin_session_get_progress(), replorigin_session_reset_internal(), replorigin_session_setup(), replorigin_state_clear(), RequestDisableLogicalDecoding(), ResetInstallXLogFileSegmentActive(), resize(), RestoreScratchTarget(), restoreTwoPhaseData(), SaveSlotToPath(), SearchNamedReplicationSlot(), SerialAdd(), SerialGetMinConflictCommitSeqNo(), SerialInit(), SerialSetActiveSerXmin(), set_indexsafe_procflags(), set_val_in_shmem(), SetCommitTsLimit(), SetInstallXLogFileSegmentActive(), SetMultiXactIdLimit(), SetNextObjectId(), SetOldestOffset(), SetTransactionIdLimit(), SetXidCommitTsInPage(), SharedInvalBackendInit(), ShmemInitStruct(), SICleanupQueue(), SIGetDataEntries(), SignalBackends(), SignalVirtualTransaction(), SIInsertDataEntries(), SimpleLruReadPage(), SimpleLruReadPage_ReadOnly(), SimpleLruTruncate(), SimpleLruWaitIO(), SimpleLruWriteAll(), SimpleLruZeroAndWritePage(), 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(), SyncRepCancelWait(), SyncRepCleanupAtProcExit(), SyncRepReleaseWaiters(), SyncRepUpdateSyncStandbysDefined(), SyncRepWaitForLSN(), TablespaceCreateDbspace(), tbm_shared_iterate(), TerminateBackgroundWorker(), TerminateBackgroundWorkersForDatabase(), TerminateOtherDBBackends(), test_aio_shmem_startup(), test_custom_stats_fixed_reset_all_cb(), test_custom_stats_fixed_snapshot_cb(), test_custom_stats_fixed_update(), test_slru_page_exists(), test_slru_page_read(), test_slru_page_readonly(), test_slru_page_write(), TransactionGroupUpdateXidStatus(), TransactionIdGetCommitTsData(), TransactionIdGetStatus(), TransactionIdIsInProgress(), TransactionIdSetPageStatus(), TransactionTreeSetCommitTsData(), TransferPredicateLocksToNewTarget(), TrimCLOG(), TrimMultiXact(), TruncateMultiXact(), TwoPhaseGetGXact(), TwoPhaseGetOldestXidInCommit(), TwoPhaseGetXidByVirtualXID(), update_cached_xid_range(), update_synced_slots_inactive_since(), UpdateLogicalDecodingStatusEndOfRecovery(), UpdateMinRecoveryPoint(), vac_truncate_clog(), vacuum_rel(), VacuumUpdateCosts(), VirtualXactLock(), VirtualXactLockTableCleanup(), VirtualXactLockTableInsert(), wait_for_table_state_change(), wait_for_worker_state_change(), WaitEventCustomNew(), WaitForReplicationWorkerAttach(), WaitForWalSummarization(), wakeupWaiters(), WakeupWalSummarizer(), WalSummarizerMain(), WalSummarizerShutdown(), write_relcache_init_file(), xact_redo(), XidCacheRemoveRunningXids(), xlog_redo(), XLogBackgroundFlush(), XLogFlush(), XLogNeedsFlush(), and XLogReportParameters().

LWLockReleaseAll()

void LWLockReleaseAll

(

void

)

Definition at line 1892 of file lwlock.c.

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

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

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

LWLockReleaseClearVar()

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

Definition at line 1866 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 fb(), LWLockRelease(), pg_atomic_exchange_u64(), and val.

Referenced by WALInsertLockRelease().

LWLockReportWaitEnd()

static void LWLockReportWaitEnd ( void  )

inlinestatic

Definition at line 728 of file lwlock.c.

{
    pgstat_report_wait_end();
}

References pgstat_report_wait_end().

Referenced by LWLockAcquire(), LWLockAcquireOrWait(), and LWLockWaitForVar().

LWLockReportWaitStart()

static void LWLockReportWaitStart ( LWLock *  lock )

inlinestatic

Definition at line 719 of file lwlock.c.

{
    pgstat_report_wait_start(PG_WAIT_LWLOCK | lock->tranche);
}

References PG_WAIT_LWLOCK, pgstat_report_wait_start(), and LWLock::tranche.

Referenced by LWLockAcquire(), LWLockAcquireOrWait(), and LWLockWaitForVar().

LWLockShmemSize()

Size LWLockShmemSize

(

void

)

Definition at line 397 of file lwlock.c.

{
    Size        size;
    int         numLocks = NUM_FIXED_LWLOCKS;
 
    /*
     * If re-initializing shared memory, the request array will no longer be
     * accessible, so switch to the copy in postmaster's local memory.  We'll
     * copy it back into shared memory later when CreateLWLocks() is called
     * again.
     */
    if (LocalNamedLWLockTrancheRequestArray)
        NamedLWLockTrancheRequestArray = LocalNamedLWLockTrancheRequestArray;
 
    /* Calculate total number of locks needed in the main array. */
    numLocks += NumLWLocksForNamedTranches();
 
    /* Space for dynamic allocation counter. */
    size = MAXALIGN(sizeof(int));
 
    /* Space for named tranches. */
    size = add_size(size, mul_size(MAX_NAMED_TRANCHES, sizeof(char *)));
    size = add_size(size, mul_size(MAX_NAMED_TRANCHES, NAMEDATALEN));
 
    /*
     * Make space for named tranche requests.  This is done for the benefit of
     * EXEC_BACKEND builds, which otherwise wouldn't be able to call
     * GetNamedLWLockTranche() outside postmaster.
     */
    size = add_size(size, mul_size(NamedLWLockTrancheRequests,
                                   sizeof(NamedLWLockTrancheRequest)));
 
    /* Space for the LWLock array, plus room for cache line alignment. */
    size = add_size(size, LWLOCK_PADDED_SIZE);
    size = add_size(size, mul_size(numLocks, sizeof(LWLockPadded)));
 
    return size;
}

References add_size(), LocalNamedLWLockTrancheRequestArray, LWLOCK_PADDED_SIZE, MAX_NAMED_TRANCHES, MAXALIGN, mul_size(), NAMEDATALEN, NamedLWLockTrancheRequestArray, NamedLWLockTrancheRequests, NUM_FIXED_LWLOCKS, and NumLWLocksForNamedTranches().

Referenced by CalculateShmemSize(), and CreateLWLocks().

LWLockUpdateVar()

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

Definition at line 1728 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, fb(), 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 1592 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);
 
        /*
         * Clear LW_FLAG_WAKE_IN_PROGRESS flag, to make sure we get woken up
         * as soon as the lock is released.
         */
        pg_atomic_fetch_and_u32(&lock->state, ~LW_FLAG_WAKE_IN_PROGRESS);
 
        /*
         * 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, fb(), HOLD_INTERRUPTS, LOG_LWDEBUG, LW_EXCLUSIVE, LW_FLAG_WAKE_IN_PROGRESS, LW_WAIT_UNTIL_FREE, LW_WS_NOT_WAITING, LWLockConflictsWithVar(), LWLockDequeueSelf(), LWLockQueueSelf(), LWLockReportWaitEnd(), LWLockReportWaitStart(), PGPROC::lwWaiting, MAX_BACKENDS, MyProc, newval, pg_atomic_fetch_and_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().

LWLockWaitListLock()

static void LWLockWaitListLock ( LWLock *  lock )

static

Definition at line 861 of file lwlock.c.

{
    uint32      old_state;
#ifdef LWLOCK_STATS
    lwlock_stats *lwstats;
    uint32      delays = 0;
 
    lwstats = get_lwlock_stats_entry(lock);
#endif
 
    while (true)
    {
        /*
         * Always try once to acquire the lock directly, without setting up
         * the spin-delay infrastructure. The work necessary for that shows up
         * in profiles and is rarely necessary.
         */
        old_state = pg_atomic_fetch_or_u32(&lock->state, LW_FLAG_LOCKED);
        if (likely(!(old_state & LW_FLAG_LOCKED)))
            break;              /* got lock */
 
        /* and then spin without atomic operations until lock is released */
        {
            SpinDelayStatus delayStatus;
 
            init_local_spin_delay(&delayStatus);
 
            while (old_state & LW_FLAG_LOCKED)
            {
                perform_spin_delay(&delayStatus);
                old_state = pg_atomic_read_u32(&lock->state);
            }
#ifdef LWLOCK_STATS
            delays += delayStatus.delays;
#endif
            finish_spin_delay(&delayStatus);
        }
 
        /*
         * Retry. The lock might obviously already be re-acquired by the time
         * we're attempting to get it again.
         */
    }
 
#ifdef LWLOCK_STATS
    lwstats->spin_delay_count += delays;
#endif
}

References fb(), finish_spin_delay(), init_local_spin_delay, likely, LW_FLAG_LOCKED, perform_spin_delay(), pg_atomic_fetch_or_u32(), pg_atomic_read_u32(), and LWLock::state.

Referenced by LWLockDequeueSelf(), LWLockQueueSelf(), LWLockUpdateVar(), and LWLockWakeup().

LWLockWaitListUnlock()

static void LWLockWaitListUnlock ( LWLock *  lock )

static

Definition at line 917 of file lwlock.c.

{
    uint32      old_state PG_USED_FOR_ASSERTS_ONLY;
 
    old_state = pg_atomic_fetch_and_u32(&lock->state, ~LW_FLAG_LOCKED);
 
    Assert(old_state & LW_FLAG_LOCKED);
}

References Assert, fb(), LW_FLAG_LOCKED, pg_atomic_fetch_and_u32(), PG_USED_FOR_ASSERTS_ONLY, and LWLock::state.

Referenced by LWLockDequeueSelf(), LWLockQueueSelf(), and LWLockUpdateVar().

LWLockWakeup()

static void LWLockWakeup ( LWLock *  lock )

static

Definition at line 930 of file lwlock.c.

{
    bool        new_wake_in_progress = false;
    bool        wokeup_somebody = false;
    proclist_head wakeup;
    proclist_mutable_iter iter;
 
    proclist_init(&wakeup);
 
    /* lock wait list while collecting backends to wake up */
    LWLockWaitListLock(lock);
 
    proclist_foreach_modify(iter, &lock->waiters, lwWaitLink)
    {
        PGPROC     *waiter = GetPGProcByNumber(iter.cur);
 
        if (wokeup_somebody && waiter->lwWaitMode == LW_EXCLUSIVE)
            continue;
 
        proclist_delete(&lock->waiters, iter.cur, lwWaitLink);
        proclist_push_tail(&wakeup, iter.cur, lwWaitLink);
 
        if (waiter->lwWaitMode != LW_WAIT_UNTIL_FREE)
        {
            /*
             * Prevent additional wakeups until retryer gets to run. Backends
             * that are just waiting for the lock to become free don't retry
             * automatically.
             */
            new_wake_in_progress = true;
 
            /*
             * Don't wakeup (further) exclusive locks.
             */
            wokeup_somebody = true;
        }
 
        /*
         * Signal that the process isn't on the wait list anymore. This allows
         * LWLockDequeueSelf() to remove itself of the waitlist with a
         * proclist_delete(), rather than having to check if it has been
         * removed from the list.
         */
        Assert(waiter->lwWaiting == LW_WS_WAITING);
        waiter->lwWaiting = LW_WS_PENDING_WAKEUP;
 
        /*
         * Once we've woken up an exclusive lock, there's no point in waking
         * up anybody else.
         */
        if (waiter->lwWaitMode == LW_EXCLUSIVE)
            break;
    }
 
    Assert(proclist_is_empty(&wakeup) || pg_atomic_read_u32(&lock->state) & LW_FLAG_HAS_WAITERS);
 
    /* unset required flags, and release lock, in one fell swoop */
    {
        uint32      old_state;
        uint32      desired_state;
 
        old_state = pg_atomic_read_u32(&lock->state);
        while (true)
        {
            desired_state = old_state;
 
            /* compute desired flags */
 
            if (new_wake_in_progress)
                desired_state |= LW_FLAG_WAKE_IN_PROGRESS;
            else
                desired_state &= ~LW_FLAG_WAKE_IN_PROGRESS;
 
            if (proclist_is_empty(&lock->waiters))
                desired_state &= ~LW_FLAG_HAS_WAITERS;
 
            desired_state &= ~LW_FLAG_LOCKED;   /* release lock */
 
            if (pg_atomic_compare_exchange_u32(&lock->state, &old_state,
                                               desired_state))
                break;
        }
    }
 
    /* Awaken any waiters I removed from the queue. */
    proclist_foreach_modify(iter, &wakeup, lwWaitLink)
    {
        PGPROC     *waiter = GetPGProcByNumber(iter.cur);
 
        LOG_LWDEBUG("LWLockRelease", lock, "release waiter");
        proclist_delete(&wakeup, iter.cur, lwWaitLink);
 
        /*
         * Guarantee that lwWaiting being unset only becomes visible once the
         * unlink from the link has completed. Otherwise the target backend
         * could be woken up for other reason and enqueue for a new lock - if
         * that happens before the list unlink happens, the list would end up
         * being corrupted.
         *
         * The barrier pairs with the LWLockWaitListLock() when enqueuing for
         * another lock.
         */
        pg_write_barrier();
        waiter->lwWaiting = LW_WS_NOT_WAITING;
        PGSemaphoreUnlock(waiter->sem);
    }
}

References Assert, proclist_mutable_iter::cur, fb(), GetPGProcByNumber, LOG_LWDEBUG, LW_EXCLUSIVE, LW_FLAG_HAS_WAITERS, LW_FLAG_WAKE_IN_PROGRESS, LW_WAIT_UNTIL_FREE, LW_WS_NOT_WAITING, LW_WS_PENDING_WAKEUP, LW_WS_WAITING, LWLockWaitListLock(), PGPROC::lwWaiting, PGPROC::lwWaitMode, pg_atomic_compare_exchange_u32(), pg_atomic_read_u32(), pg_write_barrier, PGSemaphoreUnlock(), proclist_delete, proclist_foreach_modify, proclist_init(), proclist_is_empty(), proclist_push_tail, PGPROC::sem, LWLock::state, LWLock::waiters, and wakeup.

Referenced by LWLockRelease().

NumLWLocksForNamedTranches()

static int NumLWLocksForNamedTranches ( void  )

static

Definition at line 382 of file lwlock.c.

{
    int         numLocks = 0;
    int         i;
 
    for (i = 0; i < NamedLWLockTrancheRequests; i++)
        numLocks += NamedLWLockTrancheRequestArray[i].num_lwlocks;
 
    return numLocks;
}

References i, NamedLWLockTrancheRequestArray, and NamedLWLockTrancheRequests.

Referenced by LWLockShmemSize().

RequestNamedLWLockTranche()

void RequestNamedLWLockTranche	(	const char *	tranche_name,
		int	num_lwlocks
	)

Definition at line 649 of file lwlock.c.

{
    NamedLWLockTrancheRequest *request;
    static int  NamedLWLockTrancheRequestsAllocated;
 
    if (!process_shmem_requests_in_progress)
        elog(FATAL, "cannot request additional LWLocks outside shmem_request_hook");
 
    if (!tranche_name)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_NAME),
                 errmsg("tranche name cannot be NULL")));
 
    if (strlen(tranche_name) >= NAMEDATALEN)
        ereport(ERROR,
                (errcode(ERRCODE_NAME_TOO_LONG),
                 errmsg("tranche name too long"),
                 errdetail("LWLock tranche names must be no longer than %d bytes.",
                           NAMEDATALEN - 1)));
 
    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];
    strlcpy(request->tranche_name, tranche_name, NAMEDATALEN);
    request->num_lwlocks = num_lwlocks;
    NamedLWLockTrancheRequests++;
}

References elog, ereport, errcode(), errdetail(), errmsg(), ERROR, FATAL, fb(), i, MemoryContextAlloc(), NAMEDATALEN, NamedLWLockTrancheRequestArray, NamedLWLockTrancheRequests, pg_nextpower2_32(), process_shmem_requests_in_progress, repalloc(), strlcpy(), and TopMemoryContext.

Referenced by pgss_shmem_request(), and test_lwlock_tranches_shmem_request().

StaticAssertDecl() [1/4]

StaticAssertDecl	(	((MAX_BACKENDS+1) &MAX_BACKENDS)	= =0,
		"MAX_BACKENDS + 1 needs to be a power of 2"
	)

StaticAssertDecl() [2/4]

StaticAssertDecl	(	(LW_VAL_EXCLUSIVE &LW_FLAG_MASK)	= =0,
		"LW_VAL_EXCLUSIVE and LW_FLAG_MASK overlap"
	)

StaticAssertDecl() [3/4]

StaticAssertDecl	(	(MAX_BACKENDS &LW_FLAG_MASK)	= =0,
		"MAX_BACKENDS and LW_FLAG_MASK overlap"
	)

StaticAssertDecl() [4/4]

StaticAssertDecl	(	lengthof(BuiltinTrancheNames)	= =LWTRANCHE_FIRST_USER_DEFINED,
		"missing entries in BuiltinTrancheNames"	[]
	)

Variable Documentation

BuiltinTrancheNames

const char* const BuiltinTrancheNames[]

static

Initial value:

= {
#define PG_LWLOCK(id, lockname)                              
#define PG_LWLOCKTRANCHE(id, lockname)                                          
 
 
}

Definition at line 135 of file lwlock.c.

                                                 {
#define PG_LWLOCK(id, lockname) [id] = CppAsString(lockname),
#define PG_LWLOCKTRANCHE(id, lockname) [LWTRANCHE_##id] = CppAsString(lockname),
#include "storage/lwlocklist.h"
#undef PG_LWLOCK
#undef PG_LWLOCKTRANCHE
};

Referenced by GetLWTrancheName().

held_lwlocks

LWLockHandle held_lwlocks[MAX_SIMUL_LWLOCKS]

static

Definition at line 178 of file lwlock.c.

Referenced by LWLockAcquire(), LWLockAcquireOrWait(), LWLockAnyHeldByMe(), LWLockConditionalAcquire(), LWLockHeldByMe(), LWLockHeldByMeInMode(), LWLockRelease(), and LWLockReleaseAll().

LocalLWLockCounter

int LocalLWLockCounter

static

Definition at line 202 of file lwlock.c.

Referenced by GetLWTrancheName(), and LWLockNewTrancheId().

LocalNamedLWLockTrancheRequestArray

NamedLWLockTrancheRequest* LocalNamedLWLockTrancheRequestArray = NULL

static

Definition at line 196 of file lwlock.c.

Referenced by CreateLWLocks(), and LWLockShmemSize().

LWLockCounter

int* LWLockCounter = NULL

Definition at line 199 of file lwlock.c.

Referenced by CreateLWLocks(), GetLWTrancheName(), and LWLockNewTrancheId().

LWLockTrancheNames

char** LWLockTrancheNames = NULL

Definition at line 154 of file lwlock.c.

Referenced by CreateLWLocks(), GetLWTrancheName(), and LWLockNewTrancheId().

MainLWLockArray

LWLockPadded* MainLWLockArray = NULL

Definition at line 161 of file lwlock.c.

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

NamedLWLockTrancheRequestArray

NamedLWLockTrancheRequest* NamedLWLockTrancheRequestArray = NULL

Definition at line 193 of file lwlock.c.

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

NamedLWLockTrancheRequests

int NamedLWLockTrancheRequests = 0

Definition at line 192 of file lwlock.c.

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

num_held_lwlocks

int num_held_lwlocks = 0

static

Definition at line 177 of file lwlock.c.

Referenced by LWLockAcquire(), LWLockAcquireOrWait(), LWLockAnyHeldByMe(), LWLockConditionalAcquire(), LWLockHeldByMe(), LWLockHeldByMeInMode(), LWLockRelease(), and LWLockReleaseAll().