[libc++] Implement hardware_interference_size even on Clang #83603

ldionne · 2024-03-01T18:13:13Z

We do this by hardcoding the value on a per platfrom basis and defaulting to 64, which is correct for many platforms. As part of the patch, overhaul the tests and split the definition to a separate header.

llvmbot · 2024-03-01T18:13:48Z

@llvm/pr-subscribers-libcxx

Author: Louis Dionne (ldionne)

Changes

We do this by hardcoding the value on a per platfrom basis and defaulting to 64, which is correct for many platforms. As part of the patch, overhaul the tests and split the definition to a separate header.

Patch is 22.68 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/83603.diff

15 Files Affected:

(modified) libcxx/docs/ReleaseNotes/19.rst (+1)
(modified) libcxx/docs/Status/Cxx17.rst (-1)
(modified) libcxx/docs/Status/Cxx17Papers.csv (+1-1)
(modified) libcxx/include/CMakeLists.txt (+1)
(added) libcxx/include/__new/hardware_interference_size.h (+46)
(modified) libcxx/include/libcxx.imp (+1)
(modified) libcxx/include/module.modulemap.in (+2)
(modified) libcxx/include/new (+6-11)
(modified) libcxx/include/version (+1-3)
(modified) libcxx/src/atomic.cpp (+1-1)
(removed) libcxx/test/std/language.support/support.dynamic/hardware_inference_size.compile.pass.cpp (-17)
(added) libcxx/test/std/language.support/support.dynamic/hardware_inference_size.pass.cpp (+41)
(modified) libcxx/test/std/language.support/support.limits/support.limits.general/new.version.compile.pass.cpp (+20-44)
(modified) libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp (+20-44)
(modified) libcxx/utils/generate_feature_test_macro_components.py (-2)

diff --git a/libcxx/docs/ReleaseNotes/19.rst b/libcxx/docs/ReleaseNotes/19.rst
index 0d381df5f0442c..b5c58462d85993 100644
--- a/libcxx/docs/ReleaseNotes/19.rst
+++ b/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
 -----------------------------
diff --git a/libcxx/docs/Status/Cxx17.rst b/libcxx/docs/Status/Cxx17.rst
index 99bfc7da962bdb..9ad0e1b7c3d243 100644
--- a/libcxx/docs/Status/Cxx17.rst
+++ b/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:
diff --git a/libcxx/docs/Status/Cxx17Papers.csv b/libcxx/docs/Status/Cxx17Papers.csv
index 8952391afc83b6..9be5a117bb8c3f 100644
--- a/libcxx/docs/Status/Cxx17Papers.csv
+++ b/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"
diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
index cafd8c6e00d968..d54531236e4cdf 100644
--- a/libcxx/include/CMakeLists.txt
+++ b/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
diff --git a/libcxx/include/__new/hardware_interference_size.h b/libcxx/include/__new/hardware_interference_size.h
new file mode 100644
index 00000000000000..e36049c8ee173b
--- /dev/null
+++ b/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
diff --git a/libcxx/include/libcxx.imp b/libcxx/include/libcxx.imp
index eeeae39ca101d9..b07f42991ab1e8 100644
--- a/libcxx/include/libcxx.imp
+++ b/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" ] },
diff --git a/libcxx/include/module.modulemap.in b/libcxx/include/module.modulemap.in
index 219906aa9a5668..411f0a9c3a1c97 100644
--- a/libcxx/include/module.modulemap.in
+++ b/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" }
diff --git a/libcxx/include/new b/libcxx/include/new
index 988f7a84422c84..39c49ae05af553 100644
--- a/libcxx/include/new
+++ b/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
diff --git a/libcxx/include/version b/libcxx/include/version
index 055d0f30f9c438..478566a6b88616 100644
--- a/libcxx/include/version
+++ b/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
diff --git a/libcxx/src/atomic.cpp b/libcxx/src/atomic.cpp
index 2b67685c8a0a10..196e678e73ce9a 100644
--- a/libcxx/src/atomic.cpp
+++ b/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) {}
diff --git a/libcxx/test/std/language.support/support.dynamic/hardware_inference_size.compile.pass.cpp b/libcxx/test/std/language.support/support.dynamic/hardware_inference_size.compile.pass.cpp
deleted file mode 100644
index ae277d53e46fd0..00000000000000
--- a/libcxx/test/std/language.support/support.dynamic/hardware_inference_size.compile.pass.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14
-// XFAIL: (clang || apple-clang) && stdlib=libc++
-
-#include <new>
-
-#include "test_macros.h"
-
-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);
diff --git a/libcxx/test/std/language.support/support.dynamic/hardware_inference_size.pass.cpp b/libcxx/test/std/language.support/support.dynamic/hardware_inference_size.pass.cpp
new file mode 100644
index 00000000000000..31e3559c08c243
--- /dev/null
+++ b/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;
+}
diff --git a/libcxx/test/std/language.support/support.limits/support.limits.general/new.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/new.version.compile.pass.cpp
index feb88bfb37e89b..9bf4fbc36af84b 100644
--- a/libcxx/test/std/language.support/support.limits/support.limits.general/new.version.compile.pass.cpp
+++ b/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
diff --git a/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp
index 20804d835015e2..b4fcf00016dfc5 100644
--- a/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp
+++ b/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
-#  ...
[truncated]

mordante · 2024-03-03T14:36:01Z

libcxx/include/__new/hardware_interference_size.h

+#  elif defined(__APPLE__) && defined(__arm64__)
+
+inline constexpr size_t hardware_destructive_interference_size  = 128;
+inline constexpr size_t hardware_constructive_interference_size = 128;


Is this only true for Apple 64-bit ARM platforms of for all 64-bit ARM platforms?

philnik777 · 2024-03-07T16:31:45Z

I don't really like this direction. This is something the compiler could and should provide with relative ease. I'd really like to avoid getting into hundreds of lines of

#ifdef __x86__
#ifdef __tune_znver2__
...
#elifdef __tune_corei7__
...
#else
...
#endif
#else
...
#endif

philnik777 · 2024-05-22T08:19:37Z

With #89446 landed this isn't necessary anymore.

[libc++] Implement hardware_interference_size even on Clang

2fc0b7f

We do this by hardcoding the value on a per platfrom basis and defaulting to 64, which is correct for many platforms. As part of the patch, overhaul the tests and split the definition to a separate header.

ldionne assigned philnik777 Mar 1, 2024

ldionne requested a review from a team as a code owner March 1, 2024 18:13

llvmbot added the libc++ libc++ C++ Standard Library. Not GNU libstdc++. Not libc++abi. label Mar 1, 2024

ldionne mentioned this pull request Mar 1, 2024

FR: Add cacheline size macros sufficient to support C++17 std::hardware_{con,de}structive_interference_size #60174

Closed

mordante reviewed Mar 3, 2024

View reviewed changes

philnik777 closed this May 22, 2024

ldionne deleted the review/interference_size branch May 27, 2024 14:47

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

[libc++] Implement hardware_interference_size even on Clang #83603

[libc++] Implement hardware_interference_size even on Clang #83603

ldionne commented Mar 1, 2024

llvmbot commented Mar 1, 2024

mordante Mar 3, 2024

philnik777 commented Mar 7, 2024

philnik777 commented May 22, 2024

[libc++] Implement hardware_interference_size even on Clang #83603

[libc++] Implement hardware_interference_size even on Clang #83603

Conversation

ldionne commented Mar 1, 2024

llvmbot commented Mar 1, 2024

mordante Mar 3, 2024

Choose a reason for hiding this comment

philnik777 commented Mar 7, 2024

philnik777 commented May 22, 2024