LCOV - differential code coverage report
Current view: top level - src/include/storage - spin.h (source / functions) Coverage Total Hit GNC
Current: 0e5ff9b9b45a657aea12440478dc002e9b01f138 vs 0123ce131fca454009439dfa3b2266d1d40737d7 Lines: 100.0 % 9 9 9
Current Date: 2026-03-14 14:10:32 -0400 Functions: 100.0 % 3 3 3
Baseline: lcov-20260315-024220-baseline Branches: 100.0 % 2 2 2
Baseline Date: 2026-03-14 15:27:56 +0100 Line coverage date bins:
Legend: Lines:     hit not hit
Branches: + taken - not taken # not executed
(7,30] days: 100.0 % 9 9 9
Function coverage date bins:
(7,30] days: 100.0 % 3 3 3
Branch coverage date bins:
(7,30] days: 100.0 % 2 2 2

 Age         Owner                    Branch data    TLA  Line data    Source code
                                  1                 :                : /*-------------------------------------------------------------------------
                                  2                 :                :  *
                                  3                 :                :  * spin.h
                                  4                 :                :  *     API for spinlocks.
                                  5                 :                :  *
                                  6                 :                :  *
                                  7                 :                :  *  The interface to spinlocks is defined by the typedef "slock_t" and
                                  8                 :                :  *  these functions:
                                  9                 :                :  *
                                 10                 :                :  *  void SpinLockInit(volatile slock_t *lock)
                                 11                 :                :  *      Initialize a spinlock (to the unlocked state).
                                 12                 :                :  *
                                 13                 :                :  *  void SpinLockAcquire(volatile slock_t *lock)
                                 14                 :                :  *      Acquire a spinlock, waiting if necessary.
                                 15                 :                :  *      Time out and abort() if unable to acquire the lock in a
                                 16                 :                :  *      "reasonable" amount of time --- typically ~ 1 minute.
                                 17                 :                :  *
                                 18                 :                :  *  void SpinLockRelease(volatile slock_t *lock)
                                 19                 :                :  *      Unlock a previously acquired lock.
                                 20                 :                :  *
                                 21                 :                :  *  Load and store operations in calling code are guaranteed not to be
                                 22                 :                :  *  reordered with respect to these operations, because they include a
                                 23                 :                :  *  compiler barrier.  (Before PostgreSQL 9.5, callers needed to use a
                                 24                 :                :  *  volatile qualifier to access data protected by spinlocks.)
                                 25                 :                :  *
                                 26                 :                :  *  Keep in mind the coding rule that spinlocks must not be held for more
                                 27                 :                :  *  than a few instructions.  In particular, we assume it is not possible
                                 28                 :                :  *  for a CHECK_FOR_INTERRUPTS() to occur while holding a spinlock, and so
                                 29                 :                :  *  it is not necessary to do HOLD/RESUME_INTERRUPTS() in these functions.
                                 30                 :                :  *
                                 31                 :                :  *  These functions are implemented in terms of hardware-dependent macros
                                 32                 :                :  *  supplied by s_lock.h.  There is not currently any extra functionality
                                 33                 :                :  *  added by this header, but there has been in the past and may someday
                                 34                 :                :  *  be again.
                                 35                 :                :  *
                                 36                 :                :  *
                                 37                 :                :  * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
                                 38                 :                :  * Portions Copyright (c) 1994, Regents of the University of California
                                 39                 :                :  *
                                 40                 :                :  * src/include/storage/spin.h
                                 41                 :                :  *
                                 42                 :                :  *-------------------------------------------------------------------------
                                 43                 :                :  */
                                 44                 :                : #ifndef SPIN_H
                                 45                 :                : #define SPIN_H
                                 46                 :                : 
                                 47                 :                : #include "storage/s_lock.h"
                                 48                 :                : 
                                 49                 :                : static inline void
   20 nathan@postgresql.or       50                 :GNC    18348021 : SpinLockInit(volatile slock_t *lock)
                                 51                 :                : {
                                 52                 :       18348021 :     S_INIT_LOCK(lock);
                                 53                 :       18348021 : }
                                 54                 :                : 
                                 55                 :                : static inline void
                                 56                 :       55881599 : SpinLockAcquire(volatile slock_t *lock)
                                 57                 :                : {
                                 58         [ +  + ]:       55881599 :     S_LOCK(lock);
                                 59                 :       55881599 : }
                                 60                 :                : 
                                 61                 :                : static inline void
                                 62                 :       55881599 : SpinLockRelease(volatile slock_t *lock)
                                 63                 :                : {
                                 64                 :       55881599 :     S_UNLOCK(lock);
                                 65                 :       55881599 : }
                                 66                 :                : 
                                 67                 :                : #endif                          /* SPIN_H */
        

Generated by: LCOV version 2.4-beta