[libc++] Implement hardware_interference_size even on Clang

libcxx/docs/ReleaseNotes/19.rst

@@ -43,6 +43,7 @@ Implemented Papers
 - P2819R2 - Add ``tuple`` protocol to ``complex``
 - P2302R4 - ``std::ranges::contains``
 - P1659R3 - ``std::ranges::starts_with`` and ``std::ranges::ends_with``
+- P0154R1 - ``std::hardware_interference_size`` has been implemented even when Clang is used
 
 Improvements and New Features
 -----------------------------

libcxx/docs/Status/Cxx17.rst

@@ -42,7 +42,6 @@ Paper Status
 
    .. [#note-P0067] P0067: ``std::(to|from)_chars`` for integrals has been available since version 7.0. ``std::to_chars`` for ``float`` and ``double`` since version 14.0 ``std::to_chars`` for ``long double`` uses the implementation for ``double``.
    .. [#note-P0607] P0607: The parts of P0607 that are not done are the ``<regex>`` bits.
-   .. [#note-P0154] P0154: This is currently not implemented for clang because clang does not implement the required macros.
    .. [#note-P0452] P0452: The changes to ``std::transform_inclusive_scan`` and ``std::transform_exclusive_scan`` have not yet been implemented.
 
 .. _issues-status-cxx17:

libcxx/docs/Status/Cxx17Papers.csv

@@ -35,7 +35,7 @@
 "`P0185R1 <https://wg21.link/P0185R1>`__","LWG","Adding [nothrow-]swappable traits","Jacksonville","|Complete|","3.9"
 "`P0253R1 <https://wg21.link/P0253R1>`__","LWG","Fixing a design mistake in the searchers interface","Jacksonville","|Complete|","3.9"
 "`P0025R0 <https://wg21.link/P0025R0>`__","LWG","An algorithm to ""clamp"" a value between a pair of boundary values","Jacksonville","|Complete|","3.9"
-"`P0154R1 <https://wg21.link/P0154R1>`__","LWG","constexpr std::hardware_{constructive,destructive}_interference_size","Jacksonville","|Partial| [#note-P0154]_","15.0"
+"`P0154R1 <https://wg21.link/P0154R1>`__","LWG","constexpr std::hardware_{constructive,destructive}_interference_size","Jacksonville","|Complete|","19.0"
 "`P0030R1 <https://wg21.link/P0030R1>`__","LWG","Proposal to Introduce a 3-Argument Overload to std::hypot","Jacksonville","|Complete|","3.9"
 "`P0031R0 <https://wg21.link/P0031R0>`__","LWG","A Proposal to Add Constexpr Modifiers to reverse_iterator, move_iterator, array and Range Access","Jacksonville","|Complete|","4.0"
 "`P0272R1 <https://wg21.link/P0272R1>`__","LWG","Give ``std::string``\  a non-const ``.data()``\  member function","Jacksonville","|Complete|","3.9"

libcxx/include/CMakeLists.txt

@@ -567,6 +567,7 @@ set(files
   __mutex/once_flag.h
   __mutex/tag_types.h
   __mutex/unique_lock.h
+  __new/hardware_interference_size.h
   __node_handle
   __numeric/accumulate.h
   __numeric/adjacent_difference.h

libcxx/include/__new/hardware_interference_size.h

@@ -0,0 +1,46 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___NEW_HARDWARE_INTERFERENCE_SIZE_H
+#define _LIBCPP___NEW_HARDWARE_INTERFERENCE_SIZE_H
+
+#include <__config>
+#include <cstddef>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 17
+
+#  if defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE)
+
+inline constexpr size_t hardware_destructive_interference_size  = __GCC_DESTRUCTIVE_SIZE;
+inline constexpr size_t hardware_constructive_interference_size = __GCC_CONSTRUCTIVE_SIZE;
+
+#  elif defined(__APPLE__) && defined(__arm64__)
+
+inline constexpr size_t hardware_destructive_interference_size  = 128;
+inline constexpr size_t hardware_constructive_interference_size = 128;
+
+#  else
+
+// These values are correct for most platforms
+inline constexpr size_t hardware_destructive_interference_size  = 64; // TODO: Clang should provide better values
+inline constexpr size_t hardware_constructive_interference_size = 64;
+
+#  endif
+
+#endif // _LIBCPP_STD_VER >= 17
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___NEW_HARDWARE_INTERFERENCE_SIZE_H

libcxx/include/libcxx.imp

@@ -559,6 +559,7 @@
   { include: [ "<__mutex/once_flag.h>", "private", "<mutex>", "public" ] },
   { include: [ "<__mutex/tag_types.h>", "private", "<mutex>", "public" ] },
   { include: [ "<__mutex/unique_lock.h>", "private", "<mutex>", "public" ] },
+  { include: [ "<__new/hardware_interference_size.h>", "private", "<new>", "public" ] },
   { include: [ "<__numeric/accumulate.h>", "private", "<numeric>", "public" ] },
   { include: [ "<__numeric/adjacent_difference.h>", "private", "<numeric>", "public" ] },
   { include: [ "<__numeric/exclusive_scan.h>", "private", "<numeric>", "public" ] },

libcxx/include/module.modulemap.in

@@ -1576,6 +1576,8 @@ module std_private_mutex_once_flag  [system]  { header "__mutex/once_flag.h" }
 module std_private_mutex_tag_types   [system] { header "__mutex/tag_types.h" }
 module std_private_mutex_unique_lock [system] { header "__mutex/unique_lock.h" }
 
+module std_private_new_harware_interference_size [system] { header "__new/hardware_interference_size.h" }
+
 module std_private_numeric_accumulate               [system] { header "__numeric/accumulate.h" }
 module std_private_numeric_adjacent_difference      [system] { header "__numeric/adjacent_difference.h" }
 module std_private_numeric_exclusive_scan           [system] { header "__numeric/exclusive_scan.h" }

libcxx/include/new

@@ -47,6 +47,11 @@ new_handler get_new_handler() noexcept;
 
 // 21.6.4, pointer optimization barrier
 template <class T> [[nodiscard]] constexpr T* launder(T* p) noexcept;   // C++17, nodiscard since C++20
+
+// [hardware.interference], hardware interference size
+inline constexpr size_t hardware_destructive_interference_size = implementation-defined;  // since C++17
+inline constexpr size_t hardware_constructive_interference_size = implementation-defined; // since C++17
+
 }  // std
 
 void* operator new(std::size_t size);                                   // replaceable, nodiscard in C++20
@@ -89,6 +94,7 @@ void  operator delete[](void* ptr, void*) noexcept;
 #include <__availability>
 #include <__config>
 #include <__exception/exception.h>
+#include <__new/hardware_interference_size.h>
 #include <__type_traits/is_function.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/remove_cv.h>
@@ -347,17 +353,6 @@ _LIBCPP_NODISCARD_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI constexpr _Tp* launde
 }
 #endif
 
-#if _LIBCPP_STD_VER >= 17
-
-#  if defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE)
-
-inline constexpr size_t hardware_destructive_interference_size  = __GCC_DESTRUCTIVE_SIZE;
-inline constexpr size_t hardware_constructive_interference_size = __GCC_CONSTRUCTIVE_SIZE;
-
-#  endif // defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE)
-
-#endif // _LIBCPP_STD_VER >= 17
-
 _LIBCPP_END_NAMESPACE_STD
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20

libcxx/include/version

@@ -300,9 +300,7 @@ __cpp_lib_within_lifetime                               202306L <type_traits>
 #   define __cpp_lib_filesystem                         201703L
 # endif
 # define __cpp_lib_gcd_lcm                              201606L
-# if defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE)
-#   define __cpp_lib_hardware_interference_size         201703L
-# endif
+# define __cpp_lib_hardware_interference_size           201703L
 # define __cpp_lib_has_unique_object_representations    201606L
 # define __cpp_lib_hypot                                201603L
 # define __cpp_lib_incomplete_container_elements        201505L

libcxx/src/atomic.cpp

@@ -103,7 +103,7 @@ static void __libcpp_platform_wake_by_address(__cxx_atomic_contention_t const vo
 
 static constexpr size_t __libcpp_contention_table_size = (1 << 8); /* < there's no magic in this number */
 
-struct alignas(64) /*  aim to avoid false sharing */ __libcpp_contention_table_entry {
+struct alignas(std::hardware_destructive_interference_size) __libcpp_contention_table_entry {
   __cxx_atomic_contention_t __contention_state;
   __cxx_atomic_contention_t __platform_state;
   inline constexpr __libcpp_contention_table_entry() : __contention_state(0), __platform_state(0) {}

libcxx/test/std/language.support/support.dynamic/hardware_inference_size.pass.cpp

@@ -0,0 +1,41 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <new>
+
+// inline constexpr size_t hardware_destructive_interference_size = implementation-defined;  // since C++17
+// inline constexpr size_t hardware_constructive_interference_size = implementation-defined; // since C++17
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include <new>
+#include <cassert>
+
+#include "test_macros.h"
+
+constexpr bool test() {
+  ASSERT_SAME_TYPE(decltype(std::hardware_destructive_interference_size), const std::size_t);
+  ASSERT_SAME_TYPE(decltype(std::hardware_constructive_interference_size), const std::size_t);
+
+#if defined(__APPLE__) && defined(__arm64__)
+  assert(std::hardware_destructive_interference_size == 128);
+  assert(std::hardware_constructive_interference_size == 128);
+#else
+  assert(std::hardware_destructive_interference_size == 64);
+  assert(std::hardware_constructive_interference_size == 64);
+#endif
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/language.support/support.limits/support.limits.general/new.version.compile.pass.cpp

@@ -58,17 +58,11 @@
 #   error "__cpp_lib_destroying_delete should not be defined before c++20"
 # endif
 
-# if !defined(_LIBCPP_VERSION) || (defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE))
-#   ifndef __cpp_lib_hardware_interference_size
-#     error "__cpp_lib_hardware_interference_size should be defined in c++17"
-#   endif
-#   if __cpp_lib_hardware_interference_size != 201703L
-#     error "__cpp_lib_hardware_interference_size should have the value 201703L in c++17"
-#   endif
-# else
-#   ifdef __cpp_lib_hardware_interference_size
-#     error "__cpp_lib_hardware_interference_size should not be defined when the requirement '!defined(_LIBCPP_VERSION) || (defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE))' is not met!"
-#   endif
+# ifndef __cpp_lib_hardware_interference_size
+#   error "__cpp_lib_hardware_interference_size should be defined in c++17"
+# endif
+# if __cpp_lib_hardware_interference_size != 201703L
+#   error "__cpp_lib_hardware_interference_size should have the value 201703L in c++17"
 # endif
 
 # ifndef __cpp_lib_launder
@@ -93,17 +87,11 @@
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION) || (defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE))
-#   ifndef __cpp_lib_hardware_interference_size
-#     error "__cpp_lib_hardware_interference_size should be defined in c++20"
-#   endif
-#   if __cpp_lib_hardware_interference_size != 201703L
-#     error "__cpp_lib_hardware_interference_size should have the value 201703L in c++20"
-#   endif
-# else
-#   ifdef __cpp_lib_hardware_interference_size
-#     error "__cpp_lib_hardware_interference_size should not be defined when the requirement '!defined(_LIBCPP_VERSION) || (defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE))' is not met!"
-#   endif
+# ifndef __cpp_lib_hardware_interference_size
+#   error "__cpp_lib_hardware_interference_size should be defined in c++20"
+# endif
+# if __cpp_lib_hardware_interference_size != 201703L
+#   error "__cpp_lib_hardware_interference_size should have the value 201703L in c++20"
 # endif
 
 # ifndef __cpp_lib_launder
@@ -128,17 +116,11 @@
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION) || (defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE))
-#   ifndef __cpp_lib_hardware_interference_size
-#     error "__cpp_lib_hardware_interference_size should be defined in c++23"
-#   endif
-#   if __cpp_lib_hardware_interference_size != 201703L
-#     error "__cpp_lib_hardware_interference_size should have the value 201703L in c++23"
-#   endif
-# else
-#   ifdef __cpp_lib_hardware_interference_size
-#     error "__cpp_lib_hardware_interference_size should not be defined when the requirement '!defined(_LIBCPP_VERSION) || (defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE))' is not met!"
-#   endif
+# ifndef __cpp_lib_hardware_interference_size
+#   error "__cpp_lib_hardware_interference_size should be defined in c++23"
+# endif
+# if __cpp_lib_hardware_interference_size != 201703L
+#   error "__cpp_lib_hardware_interference_size should have the value 201703L in c++23"
 # endif
 
 # ifndef __cpp_lib_launder
@@ -163,17 +145,11 @@
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION) || (defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE))
-#   ifndef __cpp_lib_hardware_interference_size
-#     error "__cpp_lib_hardware_interference_size should be defined in c++26"
-#   endif
-#   if __cpp_lib_hardware_interference_size != 201703L
-#     error "__cpp_lib_hardware_interference_size should have the value 201703L in c++26"
-#   endif
-# else
-#   ifdef __cpp_lib_hardware_interference_size
-#     error "__cpp_lib_hardware_interference_size should not be defined when the requirement '!defined(_LIBCPP_VERSION) || (defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE))' is not met!"
-#   endif
+# ifndef __cpp_lib_hardware_interference_size
+#   error "__cpp_lib_hardware_interference_size should be defined in c++26"
+# endif
+# if __cpp_lib_hardware_interference_size != 201703L
+#   error "__cpp_lib_hardware_interference_size should have the value 201703L in c++26"
 # endif
 
 # ifndef __cpp_lib_launder

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp

@@ -2289,17 +2289,11 @@
 #   error "__cpp_lib_generic_unordered_lookup should not be defined before c++20"
 # endif
 
-# if !defined(_LIBCPP_VERSION) || (defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE))
-#   ifndef __cpp_lib_hardware_interference_size
-#     error "__cpp_lib_hardware_interference_size should be defined in c++17"
-#   endif
-#   if __cpp_lib_hardware_interference_size != 201703L
-#     error "__cpp_lib_hardware_interference_size should have the value 201703L in c++17"
-#   endif
-# else
-#   ifdef __cpp_lib_hardware_interference_size
-#     error "__cpp_lib_hardware_interference_size should not be defined when the requirement '!defined(_LIBCPP_VERSION) || (defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE))' is not met!"
-#   endif
+# ifndef __cpp_lib_hardware_interference_size
+#   error "__cpp_lib_hardware_interference_size should be defined in c++17"
+# endif
+# if __cpp_lib_hardware_interference_size != 201703L
+#   error "__cpp_lib_hardware_interference_size should have the value 201703L in c++17"
 # endif
 
 # ifndef __cpp_lib_has_unique_object_representations
@@ -3503,17 +3497,11 @@
 #   error "__cpp_lib_generic_unordered_lookup should have the value 201811L in c++20"
 # endif
 
-# if !defined(_LIBCPP_VERSION) || (defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE))
-#   ifndef __cpp_lib_hardware_interference_size
-#     error "__cpp_lib_hardware_interference_size should be defined in c++20"
-#   endif
-#   if __cpp_lib_hardware_interference_size != 201703L
-#     error "__cpp_lib_hardware_interference_size should have the value 201703L in c++20"
-#   endif
-# else
-#   ifdef __cpp_lib_hardware_interference_size
-#     error "__cpp_lib_hardware_interference_size should not be defined when the requirement '!defined(_LIBCPP_VERSION) || (defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE))' is not met!"
-#   endif
+# ifndef __cpp_lib_hardware_interference_size
+#   error "__cpp_lib_hardware_interference_size should be defined in c++20"
+# endif
+# if __cpp_lib_hardware_interference_size != 201703L
+#   error "__cpp_lib_hardware_interference_size should have the value 201703L in c++20"
 # endif
 
 # ifndef __cpp_lib_has_unique_object_representations
@@ -4918,17 +4906,11 @@
 #   error "__cpp_lib_generic_unordered_lookup should have the value 201811L in c++23"
 # endif
 
-# if !defined(_LIBCPP_VERSION) || (defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE))
-#   ifndef __cpp_lib_hardware_interference_size
-#     error "__cpp_lib_hardware_interference_size should be defined in c++23"
-#   endif
-#   if __cpp_lib_hardware_interference_size != 201703L
-#     error "__cpp_lib_hardware_interference_size should have the value 201703L in c++23"
-#   endif
-# else
-#   ifdef __cpp_lib_hardware_interference_size
-#     error "__cpp_lib_hardware_interference_size should not be defined when the requirement '!defined(_LIBCPP_VERSION) || (defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE))' is not met!"
-#   endif
+# ifndef __cpp_lib_hardware_interference_size
+#   error "__cpp_lib_hardware_interference_size should be defined in c++23"
+# endif
+# if __cpp_lib_hardware_interference_size != 201703L
+#   error "__cpp_lib_hardware_interference_size should have the value 201703L in c++23"
 # endif
 
 # ifndef __cpp_lib_has_unique_object_representations
@@ -6618,17 +6600,11 @@
 #   error "__cpp_lib_generic_unordered_lookup should have the value 201811L in c++26"
 # endif
 
-# if !defined(_LIBCPP_VERSION) || (defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE))
-#   ifndef __cpp_lib_hardware_interference_size
-#     error "__cpp_lib_hardware_interference_size should be defined in c++26"
-#   endif
-#   if __cpp_lib_hardware_interference_size != 201703L
-#     error "__cpp_lib_hardware_interference_size should have the value 201703L in c++26"
-#   endif
-# else
-#   ifdef __cpp_lib_hardware_interference_size
-#     error "__cpp_lib_hardware_interference_size should not be defined when the requirement '!defined(_LIBCPP_VERSION) || (defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE))' is not met!"
-#   endif
+# ifndef __cpp_lib_hardware_interference_size
+#   error "__cpp_lib_hardware_interference_size should be defined in c++26"
+# endif
+# if __cpp_lib_hardware_interference_size != 201703L
+#   error "__cpp_lib_hardware_interference_size should have the value 201703L in c++26"
 # endif
 
 # ifndef __cpp_lib_has_unique_object_representations