Line data    Source code

       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * spin.c
       4             :  *     Hardware-independent implementation of spinlocks.
       5             :  *
       6             :  *
       7             :  * For machines that have test-and-set (TAS) instructions, s_lock.h/.c
       8             :  * define the spinlock implementation.  This file contains only a stub
       9             :  * implementation for spinlocks using PGSemaphores.  Unless semaphores
      10             :  * are implemented in a way that doesn't involve a kernel call, this
      11             :  * is too slow to be very useful :-(
      12             :  *
      13             :  *
      14             :  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
      15             :  * Portions Copyright (c) 1994, Regents of the University of California
      16             :  *
      17             :  *
      18             :  * IDENTIFICATION
      19             :  *    src/backend/storage/lmgr/spin.c
      20             :  *
      21             :  *-------------------------------------------------------------------------
      22             :  */
      23             : #include "postgres.h"
      24             : 
      25             : #include "storage/pg_sema.h"
      26             : #include "storage/shmem.h"
      27             : #include "storage/spin.h"
      28             : 
      29             : 
      30             : #ifndef HAVE_SPINLOCKS
      31             : 
      32             : /*
      33             :  * No TAS, so spinlocks are implemented as PGSemaphores.
      34             :  */
      35             : 
      36             : #ifndef HAVE_ATOMICS
      37             : #define NUM_EMULATION_SEMAPHORES (NUM_SPINLOCK_SEMAPHORES + NUM_ATOMICS_SEMAPHORES)
      38             : #else
      39             : #define NUM_EMULATION_SEMAPHORES (NUM_SPINLOCK_SEMAPHORES)
      40             : #endif                          /* HAVE_ATOMICS */
      41             : 
      42             : PGSemaphore *SpinlockSemaArray;
      43             : 
      44             : #else                           /* !HAVE_SPINLOCKS */
      45             : 
      46             : #define NUM_EMULATION_SEMAPHORES 0
      47             : 
      48             : #endif                          /* HAVE_SPINLOCKS */
      49             : 
      50             : /*
      51             :  * Report the amount of shared memory needed to store semaphores for spinlock
      52             :  * support.
      53             :  */
      54             : Size
      55        3298 : SpinlockSemaSize(void)
      56             : {
      57        3298 :     return NUM_EMULATION_SEMAPHORES * sizeof(PGSemaphore);
      58             : }
      59             : 
      60             : /*
      61             :  * Report number of semaphores needed to support spinlocks.
      62             :  */
      63             : int
      64        3298 : SpinlockSemas(void)
      65             : {
      66        3298 :     return NUM_EMULATION_SEMAPHORES;
      67             : }
      68             : 
      69             : #ifndef HAVE_SPINLOCKS
      70             : 
      71             : /*
      72             :  * Initialize spinlock emulation.
      73             :  *
      74             :  * This must be called after PGReserveSemaphores().
      75             :  */
      76             : void
      77             : SpinlockSemaInit(void)
      78             : {
      79             :     PGSemaphore *spinsemas;
      80             :     int         nsemas = SpinlockSemas();
      81             :     int         i;
      82             : 
      83             :     /*
      84             :      * We must use ShmemAllocUnlocked(), since the spinlock protecting
      85             :      * ShmemAlloc() obviously can't be ready yet.
      86             :      */
      87             :     spinsemas = (PGSemaphore *) ShmemAllocUnlocked(SpinlockSemaSize());
      88             :     for (i = 0; i < nsemas; ++i)
      89             :         spinsemas[i] = PGSemaphoreCreate();
      90             :     SpinlockSemaArray = spinsemas;
      91             : }
      92             : 
      93             : /*
      94             :  * s_lock.h hardware-spinlock emulation using semaphores
      95             :  *
      96             :  * We map all spinlocks onto NUM_EMULATION_SEMAPHORES semaphores.  It's okay to
      97             :  * map multiple spinlocks onto one semaphore because no process should ever
      98             :  * hold more than one at a time.  We just need enough semaphores so that we
      99             :  * aren't adding too much extra contention from that.
     100             :  *
     101             :  * There is one exception to the restriction of only holding one spinlock at a
     102             :  * time, which is that it's ok if emulated atomic operations are nested inside
     103             :  * spinlocks. To avoid the danger of spinlocks and atomic using the same sema,
     104             :  * we make sure "normal" spinlocks and atomics backed by spinlocks use
     105             :  * distinct semaphores (see the nested argument to s_init_lock_sema).
     106             :  *
     107             :  * slock_t is just an int for this implementation; it holds the spinlock
     108             :  * number from 1..NUM_EMULATION_SEMAPHORES.  We intentionally ensure that 0
     109             :  * is not a valid value, so that testing with this code can help find
     110             :  * failures to initialize spinlocks.
     111             :  */
     112             : 
     113             : static inline void
     114             : s_check_valid(int lockndx)
     115             : {
     116             :     if (unlikely(lockndx <= 0 || lockndx > NUM_EMULATION_SEMAPHORES))
     117             :         elog(ERROR, "invalid spinlock number: %d", lockndx);
     118             : }
     119             : 
     120             : void
     121             : s_init_lock_sema(volatile slock_t *lock, bool nested)
     122             : {
     123             :     static uint32 counter = 0;
     124             :     uint32      offset;
     125             :     uint32      sema_total;
     126             :     uint32      idx;
     127             : 
     128             :     if (nested)
     129             :     {
     130             :         /*
     131             :          * To allow nesting atomics inside spinlocked sections, use a
     132             :          * different spinlock. See comment above.
     133             :          */
     134             :         offset = 1 + NUM_SPINLOCK_SEMAPHORES;
     135             :         sema_total = NUM_ATOMICS_SEMAPHORES;
     136             :     }
     137             :     else
     138             :     {
     139             :         offset = 1;
     140             :         sema_total = NUM_SPINLOCK_SEMAPHORES;
     141             :     }
     142             : 
     143             :     idx = (counter++ % sema_total) + offset;
     144             : 
     145             :     /* double check we did things correctly */
     146             :     s_check_valid(idx);
     147             : 
     148             :     *lock = idx;
     149             : }
     150             : 
     151             : void
     152             : s_unlock_sema(volatile slock_t *lock)
     153             : {
     154             :     int         lockndx = *lock;
     155             : 
     156             :     s_check_valid(lockndx);
     157             : 
     158             :     PGSemaphoreUnlock(SpinlockSemaArray[lockndx - 1]);
     159             : }
     160             : 
     161             : bool
     162             : s_lock_free_sema(volatile slock_t *lock)
     163             : {
     164             :     /* We don't currently use S_LOCK_FREE anyway */
     165             :     elog(ERROR, "spin.c does not support S_LOCK_FREE()");
     166             :     return false;
     167             : }
     168             : 
     169             : int
     170             : tas_sema(volatile slock_t *lock)
     171             : {
     172             :     int         lockndx = *lock;
     173             : 
     174             :     s_check_valid(lockndx);
     175             : 
     176             :     /* Note that TAS macros return 0 if *success* */
     177             :     return !PGSemaphoreTryLock(SpinlockSemaArray[lockndx - 1]);
     178             : }
     179             : 
     180             : #endif                          /* !HAVE_SPINLOCKS */