[NOT FOR MERGE... yet.] Remove traditional atomics; use C11 stdatomic.h exclusively

*** NOT FOR MERGE in this cycle. ***

This commit is included to show the intended long-term destination of the
series, and to let reviewers and the buildfarm exercise the stdatomic-only
end state -- but it is deliberately NOT proposed for commit yet.  The plan is
to ship the earlier patches (which add C11 <stdatomic.h> as a *selectable*
implementation alongside the traditional platform-specific code), let the
stdatomic path prove itself in the field across the buildfarm and at least one
release, and only THEN remove the traditional implementation via a commit like
this one.  Removing the battle-tested arch-*/generic-* code on day one is not
being asked for here; keeping both paths until stdatomic has earned trust is.

Everything below describes what this (eventual) removal commit does.

This collapses the dual-path atomics into a single stdatomic-only
implementation, mirroring the destination state of the series.  Rather
than selecting between C11 <stdatomic.h> and the platform-specific
implementations at build time, stdatomic.h is now the sole backend for
PostgreSQL's atomic operations and USE_STDATOMIC_H is effectively
always-on.

The platform-specific implementation files are deleted outright:
  - src/include/port/atomics/arch-arm.h
  - src/include/port/atomics/arch-ppc.h
  - src/include/port/atomics/arch-x86.h
  - src/include/port/atomics/generic.h
  - src/include/port/atomics/generic-gcc.h
  - src/include/port/atomics/generic-msvc.h
  - src/include/port/atomics/fallback.h

atomics.h drops its #ifdef USE_STDATOMIC_H / #else conditional and the
now-dead includes of the arch-*/generic-*/fallback headers, keeping only
the stdatomic_impl.h include and the common public-API layer of static
inline pg_atomic_* wrappers.  storage/spin.h and s_lock.c lose their
traditional-spinlock (#else) branches, so only the pg_atomic_flag-based
spinlock path remains; the s_lock.h includes that served only that path
are removed.

Detection is retained but now hard-errors when a working C11
stdatomic.h is unavailable, in both meson.build and configure.ac,
instead of silently falling back.

The only remaining hand-written platform hint is the CPU spin-delay
instruction in src/include/port/spin_delay.h, which stdatomic.h does not
cover; it is intentionally left in place along with spin_delay_status.h
and stdatomic_impl.h.

This depends on the prior commits in the series (build-time detection,
stdatomic_impl.h, conditional wire-up, documentation, and the
test_atomics module).

Co-authored-by: Thomas Munro <tmunro@postgresql.org>

Author: gburd

configure

@@ -759,7 +759,6 @@ LLVM_LIBS
 CLANG
 LLVM_CONFIG
 AWK
-with_stdatomic
 with_llvm
 have_cxx
 ac_ct_CXX
@@ -858,7 +857,6 @@ with_segsize
 with_segsize_blocks
 with_wal_blocksize
 with_llvm
-with_stdatomic
 enable_depend
 enable_cassert
 with_icu
@@ -1578,8 +1576,6 @@ Optional Packages:
   --with-wal-blocksize=BLOCKSIZE
                           set WAL block size in kB [8]
   --with-llvm             build with LLVM based JIT support
-  --with-stdatomic[=yes/no/auto]
-                          use C11 stdatomic.h for atomic operations [auto]
   --without-icu           build without ICU support
   --with-tcl              build Tcl modules (PL/Tcl)
   --with-tclconfig=DIR    tclConfig.sh is in DIR
@@ -4925,22 +4921,9 @@ fi
 #
 # C11 stdatomic.h
 #
-# Accepts --with-stdatomic={yes,no,auto}.  "auto" (the default) uses
-# stdatomic.h if a compile test succeeds; "yes" requires it; "no" forces the
-# traditional platform-specific atomics.  The actual detection runs later,
-# after the compiler and 64-bit integer handling have been configured.
-
-# Check whether --with-stdatomic was given.
-if test "${with_stdatomic+set}" = set; then :
-  withval=$with_stdatomic; case $withval in
-               yes | no | auto) ;;
-               *) as_fn_error $? "invalid argument to --with-stdatomic; use yes, no, or auto" "$LINENO" 5 ;;
-             esac
-else
-  with_stdatomic=no
-fi
-
-
+# stdatomic.h is the sole atomics implementation.  The actual detection runs
+# later, after the compiler and 64-bit integer handling have been configured;
+# a missing or broken header is a hard error there.
 for ac_prog in gawk mawk nawk awk
 do
   # Extract the first word of "$ac_prog", so it can be a program name with args.
@@ -17742,11 +17725,11 @@ $as_echo "#define HAVE_GCC__ATOMIC_INT64_CAS 1" >>confdefs.h
 fi
 
 
-# Decide whether to use C11 stdatomic.h (see --with-stdatomic above).  The
-# probe mirrors the one used by the meson build: it must compile 32-bit
-# fetch_add, a seq_cst thread fence, and a 64-bit compare-exchange.
-if test "$with_stdatomic" != no; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for working C11 stdatomic.h" >&5
+# Require a working C11 stdatomic.h: it is the sole atomics implementation,
+# so a missing or broken header is a hard error.  The probe mirrors the one
+# used by the meson build: it must compile 32-bit fetch_add, a seq_cst thread
+# fence, and a 64-bit compare-exchange.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for working C11 stdatomic.h" >&5
 $as_echo_n "checking for working C11 stdatomic.h... " >&6; }
 if ${pgac_cv_stdatomic+:} false; then :
   $as_echo_n "(cached) " >&6
@@ -17758,11 +17741,11 @@ int
 main ()
 {
 _Atomic int x = 0;
-      atomic_fetch_add(&x, 1);
-      atomic_thread_fence(memory_order_seq_cst);
-      _Atomic(unsigned long long) y = 0;
-      unsigned long long expected = 0;
-      atomic_compare_exchange_strong(&y, &expected, 42);
+    atomic_fetch_add(&x, 1);
+    atomic_thread_fence(memory_order_seq_cst);
+    _Atomic(unsigned long long) y = 0;
+    unsigned long long expected = 0;
+    atomic_compare_exchange_strong(&y, &expected, 42);
 
   ;
   return 0;
@@ -17777,19 +17760,14 @@ rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $pgac_cv_stdatomic" >&5
 $as_echo "$pgac_cv_stdatomic" >&6; }
-else
-  pgac_cv_stdatomic=no
-fi
 
-if test "$with_stdatomic" = yes && test "$pgac_cv_stdatomic" != yes; then
-  as_fn_error $? "--with-stdatomic=yes was given, but a working C11 stdatomic.h could not be found" "$LINENO" 5
+if test "$pgac_cv_stdatomic" != yes; then
+  as_fn_error $? "a working C11 stdatomic.h is required (it is the only atomics implementation)" "$LINENO" 5
 fi
 
-if test "$pgac_cv_stdatomic" = yes; then
 
 $as_echo "#define USE_STDATOMIC_H 1" >>confdefs.h
 
-fi
 
 
 # Check for __get_cpuid() and __cpuid()

configure.ac

@@ -447,19 +447,9 @@ AC_SUBST(with_llvm)
 #
 # C11 stdatomic.h
 #
-# Accepts --with-stdatomic={yes,no,auto}.  "auto" (the default) uses
-# stdatomic.h if a compile test succeeds; "yes" requires it; "no" forces the
-# traditional platform-specific atomics.  The actual detection runs later,
-# after the compiler and 64-bit integer handling have been configured.
-AC_ARG_WITH(stdatomic,
-            [AS_HELP_STRING([--with-stdatomic@<:@=yes/no/auto@:>@],
-                            [use C11 stdatomic.h for atomic operations @<:@auto@:>@])],
-            [case $withval in
-               yes | no | auto) ;;
-               *) AC_MSG_ERROR([invalid argument to --with-stdatomic; use yes, no, or auto]) ;;
-             esac],
-            [with_stdatomic=no])
-AC_SUBST(with_stdatomic)
+# stdatomic.h is the sole atomics implementation.  The actual detection runs
+# later, after the compiler and 64-bit integer handling have been configured;
+# a missing or broken header is a hard error there.
 dnl must use AS_IF here, else AC_REQUIRES inside PGAC_LLVM_SUPPORT malfunctions
 AS_IF([test "$with_llvm" = yes], [
   PGAC_LLVM_SUPPORT()
@@ -2118,33 +2108,28 @@ PGAC_HAVE_GCC__ATOMIC_INT32_CAS
 PGAC_HAVE_GCC__ATOMIC_INT64_CAS
 
 
-# Decide whether to use C11 stdatomic.h (see --with-stdatomic above).  The
-# probe mirrors the one used by the meson build: it must compile 32-bit
-# fetch_add, a seq_cst thread fence, and a 64-bit compare-exchange.
-if test "$with_stdatomic" != no; then
-  AC_CACHE_CHECK([for working C11 stdatomic.h], [pgac_cv_stdatomic],
-  [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <stdatomic.h>],
-    [[_Atomic int x = 0;
-      atomic_fetch_add(&x, 1);
-      atomic_thread_fence(memory_order_seq_cst);
-      _Atomic(unsigned long long) y = 0;
-      unsigned long long expected = 0;
-      atomic_compare_exchange_strong(&y, &expected, 42);
-    ]])],
-    [pgac_cv_stdatomic=yes],
-    [pgac_cv_stdatomic=no])])
-else
-  pgac_cv_stdatomic=no
-fi
+# Require a working C11 stdatomic.h: it is the sole atomics implementation,
+# so a missing or broken header is a hard error.  The probe mirrors the one
+# used by the meson build: it must compile 32-bit fetch_add, a seq_cst thread
+# fence, and a 64-bit compare-exchange.
+AC_CACHE_CHECK([for working C11 stdatomic.h], [pgac_cv_stdatomic],
+[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <stdatomic.h>],
+  [[_Atomic int x = 0;
+    atomic_fetch_add(&x, 1);
+    atomic_thread_fence(memory_order_seq_cst);
+    _Atomic(unsigned long long) y = 0;
+    unsigned long long expected = 0;
+    atomic_compare_exchange_strong(&y, &expected, 42);
+  ]])],
+  [pgac_cv_stdatomic=yes],
+  [pgac_cv_stdatomic=no])])
 
-if test "$with_stdatomic" = yes && test "$pgac_cv_stdatomic" != yes; then
-  AC_MSG_ERROR([--with-stdatomic=yes was given, but a working C11 stdatomic.h could not be found])
+if test "$pgac_cv_stdatomic" != yes; then
+  AC_MSG_ERROR([a working C11 stdatomic.h is required (it is the only atomics implementation)])
 fi
 
-if test "$pgac_cv_stdatomic" = yes; then
-  AC_DEFINE([USE_STDATOMIC_H], 1,
-            [Define to 1 to use C11 stdatomic.h for atomic operations. (--with-stdatomic)])
-fi
+AC_DEFINE([USE_STDATOMIC_H], 1,
+          [Define to 1 to use C11 stdatomic.h for atomic operations. (--with-stdatomic)])
 
 
 # Check for __get_cpuid() and __cpuid()

meson.build

@@ -692,7 +692,6 @@ int main(void) {
 '''
 
 has_stdatomic = false
-use_stdatomic = get_option('use_stdatomic')
 
 if cc.get_id() == 'msvc'
   msvc_ver = cc.version()
@@ -730,30 +729,16 @@ else
   endif
 endif
 
-# Process the use_stdatomic option
-if use_stdatomic == 'yes'
-  if not has_stdatomic
-    error('stdatomic.h was requested with -Duse_stdatomic=yes but is not available or not working')
-  endif
-  cdata.set('USE_STDATOMIC_H', 1)
-  message('Using C11 stdatomic.h for atomic operations (forced by -Duse_stdatomic=yes)')
-  if cc.get_id() == 'msvc'
-    # MSVC needs C11 mode plus the experimental atomics switch for <stdatomic.h>.
-    cflags += ['/std:c11', '/experimental:c11atomics']
-  endif
-elif use_stdatomic == 'no'
-  message('Using traditional platform-specific atomics (forced by -Duse_stdatomic=no)')
-  # Do not set USE_STDATOMIC_H
-elif use_stdatomic == 'auto'
-  if has_stdatomic
-    cdata.set('USE_STDATOMIC_H', 1)
-    message('Using C11 stdatomic.h for atomic operations (auto-detected)')
-    if cc.get_id() == 'msvc'
-      cflags += ['/std:c11', '/experimental:c11atomics']
-    endif
-  else
-    message('Using traditional platform-specific atomics (stdatomic.h not available)')
-  endif
+# stdatomic.h is the sole atomics implementation, so a missing or broken
+# header is a hard error.
+if not has_stdatomic
+  error('a working C11 stdatomic.h is required (it is the only atomics implementation)')
+endif
+cdata.set('USE_STDATOMIC_H', 1)
+message('Using C11 stdatomic.h for atomic operations')
+if cc.get_id() == 'msvc'
+  # MSVC needs C11 mode plus the experimental atomics switch for <stdatomic.h>.
+  cflags += ['/std:c11', '/experimental:c11atomics']
 endif
 
 postgres_inc = [include_directories(postgres_inc_d)]

meson_options.txt

@@ -52,11 +52,6 @@ option('PG_TEST_EXTRA', type: 'string', value: '',
 option('PG_GIT_REVISION', type: 'string', value: 'HEAD',
   description: 'git revision to be packaged by pgdist target')
 
-option('use_stdatomic', type: 'combo',
-  choices: ['auto', 'yes', 'no'],
-  value: 'no',
-  description: 'Use C11 stdatomic.h for atomic operations (auto, yes, no)')
-
 
 # Compilation options
 

src/backend/storage/lmgr/.gitignore

@@ -1,2 +1 @@
 /lwlocknames.h
-/s_lock_test

src/backend/storage/lmgr/Makefile

@@ -24,17 +24,8 @@ OBJS = \
 
 include $(top_srcdir)/src/backend/common.mk
 
-s_lock_test: s_lock.c $(top_builddir)/src/common/libpgcommon.a $(top_builddir)/src/port/libpgport.a
-	$(CC) $(CPPFLAGS) $(CFLAGS) -DS_LOCK_TEST=1 $(srcdir)/s_lock.c \
-		-L $(top_builddir)/src/common -lpgcommon \
-		-L $(top_builddir)/src/port -lpgport -lm -o s_lock_test
-
 lwlocknames.h: ../../../include/storage/lwlocklist.h ../../utils/activity/wait_event_names.txt generate-lwlocknames.pl
 	$(PERL) $(srcdir)/generate-lwlocknames.pl $^
 
-check: s_lock_test
-	./s_lock_test
-
 clean:
-	rm -f s_lock_test
 	rm -f lwlocknames.h

src/backend/storage/lmgr/README

@@ -50,41 +50,28 @@ The rest of this README file discusses the regular lock manager in detail.
 Atomic Operations
 =================
 
-PostgreSQL's atomic operations (see src/include/port/atomics.h) can be
-implemented using either C11 stdatomic.h or traditional platform-specific
-code. The implementation is selected at build time via the USE_STDATOMIC_H
-preprocessor definition:
-
-* C11 stdatomic.h implementation (USE_STDATOMIC_H defined):
-  Uses the standard C11 <stdatomic.h> header for all atomic operations.
-  This provides better portability and potentially better compiler
-  optimizations. Available on:
+PostgreSQL's atomic operations (see src/include/port/atomics.h) are
+implemented on top of the standard C11 <stdatomic.h> header, which is the
+sole atomics implementation.  A working stdatomic.h is required at build
+time; the USE_STDATOMIC_H preprocessor symbol is always defined.  Available
+on:
   - MSVC 2022+ (requires /experimental:c11atomics flag)
   - GCC 4.9+ and Clang 3.1+ (no special flags needed)
 
-* Traditional implementation (USE_STDATOMIC_H not defined):
-  Uses platform-specific implementations that have been battle-tested
-  in PostgreSQL for many years:
-  - Architecture-specific: arch-x86.h, arch-arm.h, arch-ppc.h
-  - Compiler intrinsics: generic-gcc.h, generic-msvc.h
-  - Fallback implementations: generic.h, fallback.h
+There is no build option to select the atomics implementation: stdatomic.h
+is probed unconditionally and a missing or non-working header is a hard
+configure/build error, since there is no other implementation to fall back
+to.
 
-Both implementations provide the same public API and observable semantics.
-The choice is made at build configuration time:
+Several internal properties of the implementation are worth noting; none of
+them affect the public API:
 
-  meson setup build -Duse_stdatomic=auto  # Auto-detect (default)
-  meson setup build -Duse_stdatomic=yes   # Force stdatomic.h
-  meson setup build -Duse_stdatomic=no    # Force traditional
-
-The two implementations differ internally in several ways that do not affect
-the public API:
-
-* Memory ordering.  pg_atomic_read_u32/u64() use seq_cst ordering under
-  stdatomic.h; pg_atomic_write_u32/u64() use relaxed.  The seq_cst read was
+* Memory ordering.  pg_atomic_read_u32/u64() use seq_cst ordering;
+  pg_atomic_write_u32/u64() use relaxed.  The seq_cst read is
   required for correctness on weak-memory hardware (e.g. RISC-V), where the
   weaker relaxed and acquire orderings let a concurrent reader miss a tuple
   in a parallel hash join.  The write stays relaxed: a plain atomic store
-  matches the traditional "no barrier" contract for pg_atomic_write and, on
+  matches the "no barrier" contract for pg_atomic_write and, on
   ARM64, avoids the store-release (STLR) serialization that would penalize
   contended writes to hot shared state.  The pg_atomic_unlocked_write_*
   variant also uses relaxed ordering, consistent with its "no guarantees"
@@ -96,23 +83,15 @@ the public API:
   the thread fence (atomic_thread_fence), because a bare thread fence orders
   only atomic accesses and would let the compiler reorder plain loads/stores
   across it, whereas PostgreSQL's barrier contract must order non-atomic
-  accesses too.  This matches the traditional generic-gcc.h barriers.
+  accesses too.
 
-* Spinlock flag polarity.  The stdatomic.h pg_atomic_flag uses 1=unlocked,
-  0=locked (fetch_and-based test-and-set), the inverse of the traditional
-  0=unlocked, 1=locked (exchange-based).  This is an internal detail with no
+* Spinlock flag polarity.  The pg_atomic_flag uses 1=unlocked,
+  0=locked (fetch_and-based test-and-set).  This is an internal detail with no
   external visibility beyond raw values seen in a debugger.
 
-* Binary compatibility.  The atomic types are _Atomic(...) under stdatomic.h
-  and volatile-struct under the traditional path.  The two are not binary
-  compatible, so objects and shared memory cannot be mixed between builds;
-  the implementation is fixed at build time, so this is not a concern in
-  practice.
-
-* Platform reach.  Under stdatomic.h, 64-bit atomics are available on 32-bit
+* Platform reach.  64-bit atomics are available on 32-bit
   ARM (compiler/runtime may emulate them with locks), atomics are usable from
-  frontend programs, and the headers are C++-compatible.  The traditional
-  path disables 64-bit atomics on ARM32 and is backend-only.
+  frontend programs, and the headers are C++-compatible.
 
 For more information on memory barriers and atomic operations, see
 src/backend/storage/lmgr/README.barrier.