[libc++] Implement P0154R1 (Hardware inference size)

[philnik]

Summary

__GCC_CONSTRUCTIVE_SIZE and __GCC_DESTRUCTIVE_SIZE are available since GCC 12. I'm assuming clang will also implement these for compatability with libstdc++.

[Mordante]

Do you know whether Clang intends to implement this and if so whether they will use the same approach?
Since GCC 12 hasn't been released yet there's no CI testing done. So I would prefer to wait with this patch until we have GCC 12 in the CI.

libcxx/docs/Status/Cxx17Papers.csv

38

I don't think we can claim we're implemented this. ATM it's not implemented in Clang.
At the very least we need to add a note explaining the compiler dependency.
(Requiring using the GCC compiler means it doesn't work for all users, for example AppleClang users.)

[ldionne]

I just pinged this topic: https://discourse.llvm.org/t/rfc-c-17-hardware-constructive-destructive-interference-size/48674/37?u=ldionne

Let's see if someone from Clang jumps on it. In all cases, I really don't like implementing this on GCC only, but if that's a way to exert slight pressure on Clang to implement it, I think it's acceptable.

Requesting changes for now, but I don't see anything wrong with the patch as-is.

[ldionne]

Let's rebase this, apply my comments and land this if CI is green.

libcxx/docs/Status/Cxx17Papers.csv

30

Let's also add a release note.

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

10

Can we use // XFAIL: clang && stdlib=libc++ instead of #if defined(__cpp_lib_hardware_interference_size) ...?

[ldionne]

libcxx/docs/Status/Cxx17Papers.csv

38

Ugh yeah, that's true, we need to add a note.

[philnik]

• Address comments

[philnik]

• Rebased
• Fix release notes

[philnik]

Rebased

[philnik]

• Also XFAIL apple-clang

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_enable_shared_from_this``             ``201603L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_execution``                           *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_filesystem``                          ``201703L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_gcd_lcm``                             ``201606L``
     ------------------------------------------------- -----------------
-    ``__cpp_lib_hardware_interference_size``          *unimplemented*
+    ``__cpp_lib_hardware_interference_size``          ``201703L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_has_unique_object_representations``   ``201606L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_hypot``                               ``201603L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_incomplete_container_elements``       ``201505L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_invoke``                              ``201411L``

libcxx/docs/ReleaseNotes.rst

 
 - P0627R6 (Function to mark unreachable code)
 - P1165R1 (Make stateful allocator propagation more consistent for ``operator+(basic_string)``)
 - P0674R1 (Support arrays in ``make_shared`` and ``allocate_shared``)
 - P0980R1 (Making ``std::string`` constexpr)
 - P2216R3 (std::format improvements)
 - P0174R2 (Deprecating Vestigial Library Parts in C++17)
 - N4190 (Removing auto_ptr, random_shuffle(), And Old <functional> Stuff)
+- P0154R1 (Hardware inference size)
 
 - Marked the following papers as "Complete" (note that some of those might have
   been implemented in a previous release but not marked as such):
 
     - P1207R4 (Movability of Single-pass Iterators);
     - P1474R1 (Helpful pointers for ``ContiguousIterator``);
     - P1522R1 (Iterator Difference Type and Integer Overflow);
     - P1523R1 (Views and Size Types);

libcxx/docs/Status/Cxx17.rst

.. csv-table::
    :file: Cxx17Papers.csv
    :header-rows: 1
    :widths: auto
 
 .. note::
 
    .. [#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.
 
 .. _issues-status-cxx17:
 
 Library Working Group Issues Status
 ====================================
 
 .. csv-table::
    :file: Cxx17Issues.csv
    :header-rows: 1
    :widths: auto

libcxx/docs/Status/Cxx17Papers.csv

 "`P0092R1 <https://wg21.link/p0092r1>`__","LWG","Polishing <chrono>","Kona","|Complete|","3.8"
 "`P0007R1 <https://wg21.link/p0007r1>`__","LWG","Constant View: A proposal for a ``std::as_const``\  helper function template.","Kona","|Complete|","3.8"
 "`P0156R0 <https://wg21.link/p0156r0>`__","LWG","Variadic lock_guard(rev 3).","Kona","*Reverted in Kona*","3.9"
 "`P0074R0 <https://wg21.link/p0074r0>`__","LWG","Making ``std::owner_less``\  more flexible","Kona","|Complete|","3.8"
 "`P0013R1 <https://wg21.link/p0013r1>`__","LWG","Logical type traits rev 2","Kona","|Complete|","3.8"
 "","","","","",""
 "`P0024R2 <https://wg21.link/P0024R2>`__","LWG","The Parallelism TS Should be Standardized","Jacksonville","",""
 "`P0226R1 <https://wg21.link/P0226R1>`__","LWG","Mathematical Special Functions for C++17","Jacksonville","",""
 "`P0220R1 <https://wg21.link/P0220R1>`__","LWG","Adopt Library Fundamentals V1 TS Components for C++17","Jacksonville","|In Progress|",""
 "`P0218R1 <https://wg21.link/P0218R1>`__","LWG","Adopt the File System TS for C++17","Jacksonville","|Complete|","7.0"
 "`P0033R1 <https://wg21.link/P0033R1>`__","LWG","Re-enabling shared_from_this","Jacksonville","|Complete|","3.9"
 "`P0005R4 <https://wg21.link/P0005R4>`__","LWG","Adopt not_fn from Library Fundamentals 2 for C++17","Jacksonville","|Complete|","3.9"
 "`P0152R1 <https://wg21.link/P0152R1>`__","LWG","constexpr ``atomic::is_always_lock_free``\ ","Jacksonville","|Complete|","3.9"
 "`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","",""
+"`P0154R1 <https://wg21.link/P0154R1>`__","LWG","constexpr std::hardware_{constructive,destructive}_interference_size","Jacksonville","|Partial| [#note-P0154]_","15.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"
 "`P0077R2 <https://wg21.link/P0077R2>`__","LWG","``is_callable``\ , the missing INVOKE related trait","Jacksonville","|Complete|","3.9"
 "","","","","",""
 "`p0032r3 <https://wg21.link/p0032r3>`__","LWG","Homogeneous interface for variant, any and optional","Oulu","|Complete|","4.0"
 "`p0040r3 <https://wg21.link/p0040r3>`__","LWG","Extending memory management tools","Oulu","|Complete|","4.0"
 "`p0063r3 <https://wg21.link/p0063r3>`__","LWG","C++17 should refer to C11 instead of C99","Oulu","|Complete|","7.0"

libcxx/include/new

 template <class _Tp>
 _LIBCPP_NODISCARD_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI
 constexpr _Tp* launder(_Tp* __p) noexcept
 {
     return _VSTD::__launder(__p);
 }
 #endif
 
+#if _LIBCPP_STD_VER > 14
+
+#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 > 14
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_NEW

libcxx/include/version

 # define __cpp_lib_chrono                               201611L
 # define __cpp_lib_clamp                                201603L
 # define __cpp_lib_enable_shared_from_this              201603L
 // # define __cpp_lib_execution                            201603L
 # if !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem)
 #   define __cpp_lib_filesystem                         201703L
 # endif
 # define __cpp_lib_gcd_lcm                              201606L
-// # define __cpp_lib_hardware_interference_size           201703L
+# if defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE)
+#   define __cpp_lib_hardware_interference_size         201703L
+# endif
 # define __cpp_lib_has_unique_object_representations    201606L
 # define __cpp_lib_hypot                                201603L
 # define __cpp_lib_incomplete_container_elements        201505L
 # define __cpp_lib_invoke                               201411L
 # define __cpp_lib_is_aggregate                         201703L
 # define __cpp_lib_is_invocable                         201703L
 # define __cpp_lib_is_swappable                         201603L
 # define __cpp_lib_launder                              201606L

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

+//===----------------------------------------------------------------------===//
+//
+// 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);

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

 # endif
 
 #elif TEST_STD_VER == 17
 
 # ifdef __cpp_lib_destroying_delete
 #   error "__cpp_lib_destroying_delete should not be defined before c++20"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
+# if 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 // _LIBCPP_VERSION
+# else
 #   ifdef __cpp_lib_hardware_interference_size
-#     error "__cpp_lib_hardware_interference_size should not be defined because it is unimplemented in libc++!"
+#     error "__cpp_lib_hardware_interference_size should not be defined when defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE) is not defined!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_launder
 #   error "__cpp_lib_launder should be defined in c++17"
 # endif
 # if __cpp_lib_launder != 201606L
 #   error "__cpp_lib_launder should have the value 201606L in c++17"

 #     error "__cpp_lib_destroying_delete should have the value 201806L in c++20"
 #   endif
 # else
 #   ifdef __cpp_lib_destroying_delete
 #     error "__cpp_lib_destroying_delete should not be defined when TEST_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L is not defined!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
+# if 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 // _LIBCPP_VERSION
+# else
 #   ifdef __cpp_lib_hardware_interference_size
-#     error "__cpp_lib_hardware_interference_size should not be defined because it is unimplemented in libc++!"
+#     error "__cpp_lib_hardware_interference_size should not be defined when defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE) is not defined!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_launder
 #   error "__cpp_lib_launder should be defined in c++20"
 # endif
 # if __cpp_lib_launder != 201606L
 #   error "__cpp_lib_launder should have the value 201606L in c++20"

 #     error "__cpp_lib_destroying_delete should have the value 201806L in c++2b"
 #   endif
 # else
 #   ifdef __cpp_lib_destroying_delete
 #     error "__cpp_lib_destroying_delete should not be defined when TEST_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L is not defined!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
+# if 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++2b"
 #   endif
 #   if __cpp_lib_hardware_interference_size != 201703L
 #     error "__cpp_lib_hardware_interference_size should have the value 201703L in c++2b"
 #   endif
-# else // _LIBCPP_VERSION
+# else
 #   ifdef __cpp_lib_hardware_interference_size
-#     error "__cpp_lib_hardware_interference_size should not be defined because it is unimplemented in libc++!"
+#     error "__cpp_lib_hardware_interference_size should not be defined when defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE) is not defined!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_launder
 #   error "__cpp_lib_launder should be defined in c++2b"
 # endif
 # if __cpp_lib_launder != 201606L
 #   error "__cpp_lib_launder should have the value 201606L in c++2b"
 # endif
 
 #endif // TEST_STD_VER > 20
 

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

 # if __cpp_lib_generic_associative_lookup != 201304L
 #   error "__cpp_lib_generic_associative_lookup should have the value 201304L in c++17"
 # endif
 
 # ifdef __cpp_lib_generic_unordered_lookup
 #   error "__cpp_lib_generic_unordered_lookup should not be defined before c++20"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
+# if 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 // _LIBCPP_VERSION
+# else
 #   ifdef __cpp_lib_hardware_interference_size
-#     error "__cpp_lib_hardware_interference_size should not be defined because it is unimplemented in libc++!"
+#     error "__cpp_lib_hardware_interference_size should not be defined when defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE) is not defined!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_has_unique_object_representations
 #   error "__cpp_lib_has_unique_object_representations should be defined in c++17"
 # endif
 # if __cpp_lib_has_unique_object_representations != 201606L
 #   error "__cpp_lib_has_unique_object_representations should have the value 201606L in c++17"

 
 # ifndef __cpp_lib_generic_unordered_lookup
 #   error "__cpp_lib_generic_unordered_lookup should be defined in c++20"
 # endif
 # if __cpp_lib_generic_unordered_lookup != 201811L
 #   error "__cpp_lib_generic_unordered_lookup should have the value 201811L in c++20"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
+# if 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 // _LIBCPP_VERSION
+# else
 #   ifdef __cpp_lib_hardware_interference_size
-#     error "__cpp_lib_hardware_interference_size should not be defined because it is unimplemented in libc++!"
+#     error "__cpp_lib_hardware_interference_size should not be defined when defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE) is not defined!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_has_unique_object_representations
 #   error "__cpp_lib_has_unique_object_representations should be defined in c++20"
 # endif
 # if __cpp_lib_has_unique_object_representations != 201606L
 #   error "__cpp_lib_has_unique_object_representations should have the value 201606L in c++20"

 
 # ifndef __cpp_lib_generic_unordered_lookup
 #   error "__cpp_lib_generic_unordered_lookup should be defined in c++2b"
 # endif
 # if __cpp_lib_generic_unordered_lookup != 201811L
 #   error "__cpp_lib_generic_unordered_lookup should have the value 201811L in c++2b"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
+# if 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++2b"
 #   endif
 #   if __cpp_lib_hardware_interference_size != 201703L
 #     error "__cpp_lib_hardware_interference_size should have the value 201703L in c++2b"
 #   endif
-# else // _LIBCPP_VERSION
+# else
 #   ifdef __cpp_lib_hardware_interference_size
-#     error "__cpp_lib_hardware_interference_size should not be defined because it is unimplemented in libc++!"
+#     error "__cpp_lib_hardware_interference_size should not be defined when defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE) is not defined!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_has_unique_object_representations
 #   error "__cpp_lib_has_unique_object_representations should be defined in c++2b"
 # endif
 # if __cpp_lib_has_unique_object_representations != 201606L
 #   error "__cpp_lib_has_unique_object_representations should have the value 201606L in c++2b"

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
     "headers": ["map", "set"],
   }, {
     "name": "__cpp_lib_generic_unordered_lookup",
     "values": { "c++20": 201811 },
     "headers": ["unordered_map", "unordered_set"],
   }, {
     "name": "__cpp_lib_hardware_interference_size",
     "values": { "c++17": 201703 },
+    "test_suite_guard": "defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE)",
+    "libcxx_guard": "defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE)",
     "headers": ["new"],
-    "unimplemented": True,
   }, {
     "name": "__cpp_lib_has_unique_object_representations",
     "values": { "c++17": 201606 },
     "headers": ["type_traits"],
   }, {
     "name": "__cpp_lib_hypot",
     "values": { "c++17": 201603 },
     "headers": ["cmath"],