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

Data Structures
struct	SpinDelayStatus

Macros
#define	S_LOCK_FREE(lock) s_lock_free_sema(lock)

#define	S_UNLOCK(lock) s_unlock_sema(lock)

#define	S_INIT_LOCK(lock) s_init_lock_sema(lock, false)

#define	TAS(lock) tas_sema(lock)

#define	S_LOCK(lock) (TAS(lock) ? s_lock((lock), __FILE__, __LINE__, __func__) : 0)

#define	SPIN_DELAY() ((void) 0)

#define	TAS_SPIN(lock) TAS(lock)

#define	DEFAULT_SPINS_PER_DELAY 100

#define	init_local_spin_delay(status) init_spin_delay(status, __FILE__, __LINE__, __func__)

Typedefs
typedef int	slock_t

Functions
bool	s_lock_free_sema (volatile slock_t *lock)

void	s_unlock_sema (volatile slock_t *lock)

void	s_init_lock_sema (volatile slock_t *lock, bool nested)

int	tas_sema (volatile slock_t *lock)

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

void	set_spins_per_delay (int shared_spins_per_delay)

int	update_spins_per_delay (int shared_spins_per_delay)

static void	init_spin_delay (SpinDelayStatus status, const char file, int line, const char *func)

void	perform_spin_delay (SpinDelayStatus *status)

void	finish_spin_delay (SpinDelayStatus *status)

Macro Definition Documentation

◆ DEFAULT_SPINS_PER_DELAY

#define DEFAULT_SPINS_PER_DELAY 100

Definition at line 812 of file s_lock.h.

◆ init_local_spin_delay

#define init_local_spin_delay ( status ) init_spin_delay(status, __FILE__, __LINE__, __func__)

Definition at line 843 of file s_lock.h.

◆ S_INIT_LOCK

#define S_INIT_LOCK ( lock ) s_init_lock_sema(lock, false)

Definition at line 744 of file s_lock.h.

◆ S_LOCK

#define S_LOCK ( lock ) (TAS(lock) ? s_lock((lock), __FILE__, __LINE__, __func__) : 0)

Definition at line 756 of file s_lock.h.

◆ S_LOCK_FREE

#define S_LOCK_FREE ( lock ) s_lock_free_sema(lock)

Definition at line 742 of file s_lock.h.

◆ S_UNLOCK

#define S_UNLOCK ( lock ) s_unlock_sema(lock)

Definition at line 743 of file s_lock.h.

◆ SPIN_DELAY

#define SPIN_DELAY ( ) ((void) 0)

Definition at line 791 of file s_lock.h.

◆ TAS

#define TAS ( lock ) tas_sema(lock)

Definition at line 745 of file s_lock.h.

◆ TAS_SPIN

#define TAS_SPIN ( lock ) TAS(lock)

Definition at line 802 of file s_lock.h.

Typedef Documentation

◆ slock_t

typedef int slock_t

Definition at line 735 of file s_lock.h.

Function Documentation

◆ finish_spin_delay()

void finish_spin_delay ( SpinDelayStatus * status )

Definition at line 192 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().

◆ init_spin_delay()

static void init_spin_delay	(	SpinDelayStatus *	status,
		const char *	file,
		int	line,
		const char *	func
	)

inlinestatic

Definition at line 832 of file s_lock.h.

 {
     status->spins = 0;
     status->delays = 0;
     status->cur_delay = 0;
     status->file = file;
     status->line = line;
     status->func = func;
 }

References SpinDelayStatus::cur_delay, SpinDelayStatus::delays, SpinDelayStatus::file, SpinDelayStatus::func, SpinDelayStatus::line, and SpinDelayStatus::spins.

Referenced by s_lock().

◆ perform_spin_delay()

void perform_spin_delay ( SpinDelayStatus * status )

Definition at line 132 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, fflush(), 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_init_lock_sema()

void s_init_lock_sema	(	volatile slock_t *	lock,
		bool	nested
	)

Definition at line 121 of file spin.c.

 {
     static uint32 counter = 0;
     uint32      offset;
     uint32      sema_total;
     uint32      idx;
  
     if (nested)
     {
         /*
          * To allow nesting atomics inside spinlocked sections, use a
          * different spinlock. See comment above.
          */
         offset = 1 + NUM_SPINLOCK_SEMAPHORES;
         sema_total = NUM_ATOMICS_SEMAPHORES;
     }
     else
     {
         offset = 1;
         sema_total = NUM_SPINLOCK_SEMAPHORES;
     }
  
     idx = (counter++ % sema_total) + offset;
  
     /* double check we did things correctly */
     s_check_valid(idx);
  
     *lock = idx;
 }

References idx(), NUM_ATOMICS_SEMAPHORES, NUM_SPINLOCK_SEMAPHORES, and s_check_valid().

Referenced by pg_atomic_init_flag_impl(), pg_atomic_init_u32_impl(), and pg_atomic_init_u64_impl().

◆ s_lock()

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

Definition at line 99 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_free_sema()

bool s_lock_free_sema ( volatile slock_t * lock )

Definition at line 162 of file spin.c.

 {
     /* We don't currently use S_LOCK_FREE anyway */
     elog(ERROR, "spin.c does not support S_LOCK_FREE()");
     return false;
 }

References elog, and ERROR.

◆ s_unlock_sema()

void s_unlock_sema ( volatile slock_t * lock )

Definition at line 152 of file spin.c.

 {
     int         lockndx = *lock;
  
     s_check_valid(lockndx);
  
     PGSemaphoreUnlock(SpinlockSemaArray[lockndx - 1]);
 }

References PGSemaphoreUnlock(), s_check_valid(), and SpinlockSemaArray.

◆ set_spins_per_delay()

void set_spins_per_delay ( int shared_spins_per_delay )

Definition at line 213 of file s_lock.c.

 {
     spins_per_delay = shared_spins_per_delay;
 }

References spins_per_delay.

Referenced by InitAuxiliaryProcess(), and InitProcess().

◆ tas_sema()

int tas_sema ( volatile slock_t * lock )

Definition at line 170 of file spin.c.

 {
     int         lockndx = *lock;
  
     s_check_valid(lockndx);
  
     /* Note that TAS macros return 0 if *success* */
     return !PGSemaphoreTryLock(SpinlockSemaArray[lockndx - 1]);
 }

References PGSemaphoreTryLock(), s_check_valid(), and SpinlockSemaArray.

◆ update_spins_per_delay()

int update_spins_per_delay ( int shared_spins_per_delay )

Definition at line 224 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;
 }