#include "postgres.h"
#include <time.h>
#include <unistd.h>
#include "common/pg_prng.h"
#include "storage/s_lock.h"
#include "utils/wait_event.h"

Include dependency graph for s_lock.c:

Macros
#define	MIN_SPINS_PER_DELAY 10

#define	MAX_SPINS_PER_DELAY 1000

#define	NUM_DELAYS 1000

#define	MIN_DELAY_USEC 1000L

#define	MAX_DELAY_USEC 1000000L

Functions
static void	s_lock_stuck (const char file, int line, const char func)

int	s_lock (volatile slock_t lock, const char file, int line, const char *func)

void	s_unlock (volatile slock_t *lock)

void	perform_spin_delay (SpinDelayStatus *status)

void	finish_spin_delay (SpinDelayStatus *status)

void	set_spins_per_delay (int shared_spins_per_delay)

int	update_spins_per_delay (int shared_spins_per_delay)

Variables
static int	spins_per_delay = DEFAULT_SPINS_PER_DELAY

Macro Definition Documentation

◆ MAX_DELAY_USEC

#define MAX_DELAY_USEC 1000000L

Definition at line 61 of file s_lock.c.

◆ MAX_SPINS_PER_DELAY

#define MAX_SPINS_PER_DELAY 1000

Definition at line 58 of file s_lock.c.

◆ MIN_DELAY_USEC

#define MIN_DELAY_USEC 1000L

Definition at line 60 of file s_lock.c.

◆ MIN_SPINS_PER_DELAY

#define MIN_SPINS_PER_DELAY 10

Definition at line 57 of file s_lock.c.

◆ NUM_DELAYS

#define NUM_DELAYS 1000

Definition at line 59 of file s_lock.c.

Function Documentation

◆ finish_spin_delay()

void finish_spin_delay ( SpinDelayStatus * status )

Definition at line 186 of file s_lock.c.

{
    if (status->cur_delay == 0)
    {
        /* we never had to delay */
        if (spins_per_delay < MAX_SPINS_PER_DELAY)
            spins_per_delay = Min(spins_per_delay + 100, MAX_SPINS_PER_DELAY);
    }
    else
    {
        if (spins_per_delay > MIN_SPINS_PER_DELAY)
            spins_per_delay = Max(spins_per_delay - 1, MIN_SPINS_PER_DELAY);
    }
}

References SpinDelayStatus::cur_delay, Max, MAX_SPINS_PER_DELAY, Min, MIN_SPINS_PER_DELAY, and spins_per_delay.

Referenced by LockBufHdr(), LWLockWaitListLock(), s_lock(), and WaitBufHdrUnlocked().

◆ perform_spin_delay()

void perform_spin_delay ( SpinDelayStatus * status )

Definition at line 126 of file s_lock.c.

{
    /* CPU-specific delay each time through the loop */
    SPIN_DELAY();
 
    /* Block the process every spins_per_delay tries */
    if (++(status->spins) >= spins_per_delay)
    {
        if (++(status->delays) > NUM_DELAYS)
            s_lock_stuck(status->file, status->line, status->func);
 
        if (status->cur_delay == 0) /* first time to delay? */
            status->cur_delay = MIN_DELAY_USEC;
 
        /*
         * Once we start sleeping, the overhead of reporting a wait event is
         * justified. Actively spinning easily stands out in profilers, but
         * sleeping with an exponential backoff is harder to spot...
         *
         * We might want to report something more granular at some point, but
         * this is better than nothing.
         */
        pgstat_report_wait_start(WAIT_EVENT_SPIN_DELAY);
        pg_usleep(status->cur_delay);
        pgstat_report_wait_end();
 
#if defined(S_LOCK_TEST)
        fprintf(stdout, "*");
        fflush(stdout);
#endif
 
        /* increase delay by a random fraction between 1X and 2X */
        status->cur_delay += (int) (status->cur_delay *
                                    pg_prng_double(&pg_global_prng_state) + 0.5);
        /* wrap back to minimum delay when max is exceeded */
        if (status->cur_delay > MAX_DELAY_USEC)
            status->cur_delay = MIN_DELAY_USEC;
 
        status->spins = 0;
    }
}

References SpinDelayStatus::cur_delay, SpinDelayStatus::delays, SpinDelayStatus::file, fprintf, SpinDelayStatus::func, SpinDelayStatus::line, MAX_DELAY_USEC, MIN_DELAY_USEC, NUM_DELAYS, pg_global_prng_state, pg_prng_double(), pg_usleep(), pgstat_report_wait_end(), pgstat_report_wait_start(), s_lock_stuck(), SPIN_DELAY, SpinDelayStatus::spins, spins_per_delay, and generate_unaccent_rules::stdout.

Referenced by LockBufHdr(), LWLockWaitListLock(), s_lock(), and WaitBufHdrUnlocked().

◆ s_lock()

int s_lock	(	volatile slock_t *	lock,
		const char *	file,
		int	line,
		const char *	func
	)

Definition at line 98 of file s_lock.c.

{
    SpinDelayStatus delayStatus;
 
    init_spin_delay(&delayStatus, file, line, func);
 
    while (TAS_SPIN(lock))
    {
        perform_spin_delay(&delayStatus);
    }
 
    finish_spin_delay(&delayStatus);
 
    return delayStatus.delays;
}

References SpinDelayStatus::delays, finish_spin_delay(), init_spin_delay(), perform_spin_delay(), and TAS_SPIN.

Referenced by test_spinlock().

◆ s_lock_stuck()

static void s_lock_stuck	(	const char *	file,
		int	line,
		const char *	func
	)

static

Definition at line 79 of file s_lock.c.

{
    if (!func)
        func = "(unknown)";
#if defined(S_LOCK_TEST)
    fprintf(stderr,
            "\nStuck spinlock detected at %s, %s:%d.\n",
            func, file, line);
    exit(1);
#else
    elog(PANIC, "stuck spinlock detected at %s, %s:%d",
         func, file, line);
#endif
}

References elog, fprintf, and PANIC.

Referenced by perform_spin_delay().

◆ s_unlock()

void s_unlock ( volatile slock_t * lock )

Definition at line 116 of file s_lock.c.

{
    *lock = 0;
}

◆ set_spins_per_delay()

void set_spins_per_delay ( int shared_spins_per_delay )

Definition at line 207 of file s_lock.c.

{
    spins_per_delay = shared_spins_per_delay;
}

References spins_per_delay.

Referenced by InitAuxiliaryProcess(), and InitProcess().

◆ update_spins_per_delay()

int update_spins_per_delay ( int shared_spins_per_delay )

Definition at line 218 of file s_lock.c.

{
    /*
     * We use an exponential moving average with a relatively slow adaption
     * rate, so that noise in any one backend's result won't affect the shared
     * value too much.  As long as both inputs are within the allowed range,
     * the result must be too, so we need not worry about clamping the result.
     *
     * We deliberately truncate rather than rounding; this is so that single
     * adjustments inside a backend can affect the shared estimate (see the
     * asymmetric adjustment rules above).
     */
    return (shared_spins_per_delay * 15 + spins_per_delay) / 16;
}

References spins_per_delay.

Referenced by AuxiliaryProcKill(), and ProcKill().

Variable Documentation

◆ spins_per_delay

int spins_per_delay = DEFAULT_SPINS_PER_DELAY