From 06ebb8835022b92ea64c5b10bdb3f5afbad0e5f8 Mon Sep 17 00:00:00 2001 From: Tomi Valkeinen Date: Thu, 18 Dec 2025 12:28:37 +0200 Subject: Update mdspan headers to 546d4dd63697c6a331554adb6fe650e09b690812 --- .../experimental/__p0009_bits/compressed_pair.hpp | 206 ++++----- .../include/experimental/__p0009_bits/config.hpp | 197 ++++---- .../experimental/__p0009_bits/default_accessor.hpp | 2 +- .../experimental/__p0009_bits/dynamic_extent.hpp | 2 +- .../include/experimental/__p0009_bits/extents.hpp | 95 ++-- .../experimental/__p0009_bits/full_extent_t.hpp | 2 +- .../experimental/__p0009_bits/layout_left.hpp | 94 ++-- .../experimental/__p0009_bits/layout_right.hpp | 98 ++-- .../experimental/__p0009_bits/layout_stride.hpp | 260 ++++++----- .../include/experimental/__p0009_bits/macros.hpp | 363 +++++++-------- .../include/experimental/__p0009_bits/mdspan.hpp | 280 ++++++++---- .../__p0009_bits/no_unique_address.hpp | 72 +-- .../experimental/__p0009_bits/trait_backports.hpp | 46 +- .../experimental/__p0009_bits/type_list.hpp | 67 ++- .../include/experimental/__p0009_bits/utility.hpp | 80 +++- .../include/experimental/__p1684_bits/mdarray.hpp | 106 ++--- .../experimental/__p2630_bits/strided_slice.hpp | 18 +- .../__p2630_bits/submdspan_mapping.hpp | 42 +- .../experimental/__p2642_bits/layout_padded.hpp | 496 +++++++++++++++------ .../__p2642_bits/layout_padded_fwd.hpp | 86 ++-- 20 files changed, 1516 insertions(+), 1096 deletions(-) diff --git a/ext/mdspan/include/experimental/__p0009_bits/compressed_pair.hpp b/ext/mdspan/include/experimental/__p0009_bits/compressed_pair.hpp index 25389a2..5a6e945 100644 --- a/ext/mdspan/include/experimental/__p0009_bits/compressed_pair.hpp +++ b/ext/mdspan/include/experimental/__p0009_bits/compressed_pair.hpp @@ -18,7 +18,7 @@ #include "macros.hpp" #include "trait_backports.hpp" -#if !defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) +#if !defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) # include "no_unique_address.hpp" #endif @@ -27,169 +27,169 @@ namespace detail { // For no unique address emulation, this is the case taken when neither are empty. // For real `[[no_unique_address]]`, this case is always taken. -template struct __compressed_pair { - _MDSPAN_NO_UNIQUE_ADDRESS _T1 __t1_val{}; - _MDSPAN_NO_UNIQUE_ADDRESS _T2 __t2_val{}; - MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T1 &__first() noexcept { return __t1_val; } - MDSPAN_FORCE_INLINE_FUNCTION constexpr _T1 const &__first() const noexcept { - return __t1_val; +template struct impl_compressed_pair { + MDSPAN_IMPL_NO_UNIQUE_ADDRESS T1 m_t1_val{}; + MDSPAN_IMPL_NO_UNIQUE_ADDRESS T2 m_t2_val{}; + MDSPAN_FORCE_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 T1 &first() noexcept { return m_t1_val; } + MDSPAN_FORCE_INLINE_FUNCTION constexpr T1 const &first() const noexcept { + return m_t1_val; } - MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T2 &__second() noexcept { return __t2_val; } - MDSPAN_FORCE_INLINE_FUNCTION constexpr _T2 const &__second() const noexcept { - return __t2_val; + MDSPAN_FORCE_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 T2 &second() noexcept { return m_t2_val; } + MDSPAN_FORCE_INLINE_FUNCTION constexpr T2 const &second() const noexcept { + return m_t2_val; } MDSPAN_INLINE_FUNCTION_DEFAULTED - constexpr __compressed_pair() = default; + constexpr impl_compressed_pair() = default; MDSPAN_INLINE_FUNCTION_DEFAULTED - constexpr __compressed_pair(__compressed_pair const &) = default; + constexpr impl_compressed_pair(impl_compressed_pair const &) = default; MDSPAN_INLINE_FUNCTION_DEFAULTED - constexpr __compressed_pair(__compressed_pair &&) = default; + constexpr impl_compressed_pair(impl_compressed_pair &&) = default; MDSPAN_INLINE_FUNCTION_DEFAULTED - _MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair & - operator=(__compressed_pair const &) = default; + MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED impl_compressed_pair & + operator=(impl_compressed_pair const &) = default; MDSPAN_INLINE_FUNCTION_DEFAULTED - _MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair & - operator=(__compressed_pair &&) = default; + MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED impl_compressed_pair & + operator=(impl_compressed_pair &&) = default; MDSPAN_INLINE_FUNCTION_DEFAULTED - ~__compressed_pair() = default; - template - MDSPAN_INLINE_FUNCTION constexpr __compressed_pair(_T1Like &&__t1, _T2Like &&__t2) - : __t1_val((_T1Like &&) __t1), __t2_val((_T2Like &&) __t2) {} + ~impl_compressed_pair() = default; + template + MDSPAN_INLINE_FUNCTION constexpr impl_compressed_pair(T1Like &&t1, T2Like &&t2) + : m_t1_val((T1Like &&) t1), m_t2_val((T2Like &&) t2) {} }; -#if !defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) +#if !defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) // First empty. -template -struct __compressed_pair< - _T1, _T2, - std::enable_if_t<_MDSPAN_TRAIT(std::is_empty, _T1) && !_MDSPAN_TRAIT(std::is_empty, _T2)>> - : private _T1 { - _T2 __t2_val{}; - MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T1 &__first() noexcept { - return *static_cast<_T1 *>(this); +template +struct impl_compressed_pair< + T1, T2, + std::enable_if_t> + : private T1 { + T2 m_t2_val{}; + MDSPAN_FORCE_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 T1 &first() noexcept { + return *static_cast(this); } - MDSPAN_FORCE_INLINE_FUNCTION constexpr _T1 const &__first() const noexcept { - return *static_cast<_T1 const *>(this); + MDSPAN_FORCE_INLINE_FUNCTION constexpr T1 const &first() const noexcept { + return *static_cast(this); } - MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T2 &__second() noexcept { return __t2_val; } - MDSPAN_FORCE_INLINE_FUNCTION constexpr _T2 const &__second() const noexcept { - return __t2_val; + MDSPAN_FORCE_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 T2 &second() noexcept { return m_t2_val; } + MDSPAN_FORCE_INLINE_FUNCTION constexpr T2 const &second() const noexcept { + return m_t2_val; } MDSPAN_INLINE_FUNCTION_DEFAULTED - constexpr __compressed_pair() = default; + constexpr impl_compressed_pair() = default; MDSPAN_INLINE_FUNCTION_DEFAULTED - constexpr __compressed_pair(__compressed_pair const &) = default; + constexpr impl_compressed_pair(impl_compressed_pair const &) = default; MDSPAN_INLINE_FUNCTION_DEFAULTED - constexpr __compressed_pair(__compressed_pair &&) = default; + constexpr impl_compressed_pair(impl_compressed_pair &&) = default; MDSPAN_INLINE_FUNCTION_DEFAULTED - _MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair & - operator=(__compressed_pair const &) = default; + MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED impl_compressed_pair & + operator=(impl_compressed_pair const &) = default; MDSPAN_INLINE_FUNCTION_DEFAULTED - _MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair & - operator=(__compressed_pair &&) = default; + MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED impl_compressed_pair & + operator=(impl_compressed_pair &&) = default; MDSPAN_INLINE_FUNCTION_DEFAULTED - ~__compressed_pair() = default; - template - MDSPAN_INLINE_FUNCTION constexpr __compressed_pair(_T1Like &&__t1, _T2Like &&__t2) - : _T1((_T1Like &&) __t1), __t2_val((_T2Like &&) __t2) {} + ~impl_compressed_pair() = default; + template + MDSPAN_INLINE_FUNCTION constexpr impl_compressed_pair(T1Like &&t1, T2Like &&t2) + : T1((T1Like &&) t1), m_t2_val((T2Like &&) t2) {} }; // Second empty. -template -struct __compressed_pair< - _T1, _T2, - std::enable_if_t> - : private _T2 { - _T1 __t1_val{}; - MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T1 &__first() noexcept { return __t1_val; } - MDSPAN_FORCE_INLINE_FUNCTION constexpr _T1 const &__first() const noexcept { - return __t1_val; +template +struct impl_compressed_pair< + T1, T2, + std::enable_if_t> + : private T2 { + T1 m_t1_val{}; + MDSPAN_FORCE_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 T1 &first() noexcept { return m_t1_val; } + MDSPAN_FORCE_INLINE_FUNCTION constexpr T1 const &first() const noexcept { + return m_t1_val; } - MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T2 &__second() noexcept { - return *static_cast<_T2 *>(this); + MDSPAN_FORCE_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 T2 &second() noexcept { + return *static_cast(this); } - MDSPAN_FORCE_INLINE_FUNCTION constexpr _T2 const &__second() const noexcept { - return *static_cast<_T2 const *>(this); + MDSPAN_FORCE_INLINE_FUNCTION constexpr T2 const &second() const noexcept { + return *static_cast(this); } MDSPAN_INLINE_FUNCTION_DEFAULTED - constexpr __compressed_pair() = default; + constexpr impl_compressed_pair() = default; MDSPAN_INLINE_FUNCTION_DEFAULTED - constexpr __compressed_pair(__compressed_pair const &) = default; + constexpr impl_compressed_pair(impl_compressed_pair const &) = default; MDSPAN_INLINE_FUNCTION_DEFAULTED - constexpr __compressed_pair(__compressed_pair &&) = default; + constexpr impl_compressed_pair(impl_compressed_pair &&) = default; MDSPAN_INLINE_FUNCTION_DEFAULTED - _MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair & - operator=(__compressed_pair const &) = default; + MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED impl_compressed_pair & + operator=(impl_compressed_pair const &) = default; MDSPAN_INLINE_FUNCTION_DEFAULTED - _MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair & - operator=(__compressed_pair &&) = default; + MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED impl_compressed_pair & + operator=(impl_compressed_pair &&) = default; MDSPAN_INLINE_FUNCTION_DEFAULTED - ~__compressed_pair() = default; + ~impl_compressed_pair() = default; - template - MDSPAN_INLINE_FUNCTION constexpr __compressed_pair(_T1Like &&__t1, _T2Like &&__t2) - : _T2((_T2Like &&) __t2), __t1_val((_T1Like &&) __t1) {} + template + MDSPAN_INLINE_FUNCTION constexpr impl_compressed_pair(T1Like &&t1, T2Like &&t2) + : T2((T2Like &&) t2), m_t1_val((T1Like &&) t1) {} }; // Both empty. -template -struct __compressed_pair< - _T1, _T2, - std::enable_if_t<_MDSPAN_TRAIT(std::is_empty, _T1) && _MDSPAN_TRAIT(std::is_empty, _T2)>> - // We need to use the __no_unique_address_emulation wrapper here to avoid +template +struct impl_compressed_pair< + T1, T2, + std::enable_if_t> + // We need to use the no_unique_address_emulation wrapper here to avoid // base class ambiguities. -#ifdef _MDSPAN_COMPILER_MSVC +#ifdef MDSPAN_IMPL_COMPILER_MSVC // MSVC doesn't allow you to access public static member functions of a type // when you *happen* to privately inherit from that type. - : protected __no_unique_address_emulation<_T1, 0>, - protected __no_unique_address_emulation<_T2, 1> + : protected no_unique_address_emulation, + protected no_unique_address_emulation #else - : private __no_unique_address_emulation<_T1, 0>, - private __no_unique_address_emulation<_T2, 1> + : private no_unique_address_emulation, + private no_unique_address_emulation #endif { - using __first_base_t = __no_unique_address_emulation<_T1, 0>; - using __second_base_t = __no_unique_address_emulation<_T2, 1>; + using first_base_t = no_unique_address_emulation; + using second_base_t = no_unique_address_emulation; - MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T1 &__first() noexcept { - return this->__first_base_t::__ref(); + MDSPAN_FORCE_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 T1 &first() noexcept { + return this->first_base_t::ref(); } - MDSPAN_FORCE_INLINE_FUNCTION constexpr _T1 const &__first() const noexcept { - return this->__first_base_t::__ref(); + MDSPAN_FORCE_INLINE_FUNCTION constexpr T1 const &first() const noexcept { + return this->first_base_t::ref(); } - MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T2 &__second() noexcept { - return this->__second_base_t::__ref(); + MDSPAN_FORCE_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 T2 &second() noexcept { + return this->second_base_t::ref(); } - MDSPAN_FORCE_INLINE_FUNCTION constexpr _T2 const &__second() const noexcept { - return this->__second_base_t::__ref(); + MDSPAN_FORCE_INLINE_FUNCTION constexpr T2 const &second() const noexcept { + return this->second_base_t::ref(); } MDSPAN_INLINE_FUNCTION_DEFAULTED - constexpr __compressed_pair() = default; + constexpr impl_compressed_pair() = default; MDSPAN_INLINE_FUNCTION_DEFAULTED - constexpr __compressed_pair(__compressed_pair const &) = default; + constexpr impl_compressed_pair(impl_compressed_pair const &) = default; MDSPAN_INLINE_FUNCTION_DEFAULTED - constexpr __compressed_pair(__compressed_pair &&) = default; + constexpr impl_compressed_pair(impl_compressed_pair &&) = default; MDSPAN_INLINE_FUNCTION_DEFAULTED - _MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair & - operator=(__compressed_pair const &) = default; + MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED impl_compressed_pair & + operator=(impl_compressed_pair const &) = default; MDSPAN_INLINE_FUNCTION_DEFAULTED - _MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair & - operator=(__compressed_pair &&) = default; + MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED impl_compressed_pair & + operator=(impl_compressed_pair &&) = default; MDSPAN_INLINE_FUNCTION_DEFAULTED - ~__compressed_pair() = default; - template - MDSPAN_INLINE_FUNCTION constexpr __compressed_pair(_T1Like &&__t1, _T2Like &&__t2) noexcept - : __first_base_t(_T1((_T1Like &&) __t1)), - __second_base_t(_T2((_T2Like &&) __t2)) + ~impl_compressed_pair() = default; + template + MDSPAN_INLINE_FUNCTION constexpr impl_compressed_pair(T1Like &&t1, T2Like &&t2) noexcept + : first_base_t(T1((T1Like &&) t1)), + second_base_t(T2((T2Like &&) t2)) { } }; -#endif // !defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) +#endif // !defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) } // end namespace detail } // end namespace MDSPAN_IMPL_STANDARD_NAMESPACE diff --git a/ext/mdspan/include/experimental/__p0009_bits/config.hpp b/ext/mdspan/include/experimental/__p0009_bits/config.hpp index a23d013..9a00e42 100644 --- a/ext/mdspan/include/experimental/__p0009_bits/config.hpp +++ b/ext/mdspan/include/experimental/__p0009_bits/config.hpp @@ -15,11 +15,15 @@ //@HEADER #pragma once -#ifndef __has_include -# define __has_include(x) 0 +#ifndef MDSPAN_IMPL_HAS_INCLUDE +# ifndef __has_include +# define MDSPAN_IMPL_HAS_INCLUDE(x) 0 +# else +# define MDSPAN_IMPL_HAS_INCLUDE(x) __has_include(x) +# endif #endif -#if __has_include() +#if MDSPAN_IMPL_HAS_INCLUDE() # include #else # include @@ -27,9 +31,9 @@ #endif #ifdef _MSVC_LANG -#define _MDSPAN_CPLUSPLUS _MSVC_LANG +#define MDSPAN_IMPL_CPLUSPLUS _MSVC_LANG #else -#define _MDSPAN_CPLUSPLUS __cplusplus +#define MDSPAN_IMPL_CPLUSPLUS __cplusplus #endif #define MDSPAN_CXX_STD_14 201402L @@ -42,190 +46,201 @@ #define MDSPAN_CXX_STD_23 202100L #endif -#define MDSPAN_HAS_CXX_14 (_MDSPAN_CPLUSPLUS >= MDSPAN_CXX_STD_14) -#define MDSPAN_HAS_CXX_17 (_MDSPAN_CPLUSPLUS >= MDSPAN_CXX_STD_17) -#define MDSPAN_HAS_CXX_20 (_MDSPAN_CPLUSPLUS >= MDSPAN_CXX_STD_20) -#define MDSPAN_HAS_CXX_23 (_MDSPAN_CPLUSPLUS >= MDSPAN_CXX_STD_23) +#define MDSPAN_HAS_CXX_14 (MDSPAN_IMPL_CPLUSPLUS >= MDSPAN_CXX_STD_14) +#define MDSPAN_HAS_CXX_17 (MDSPAN_IMPL_CPLUSPLUS >= MDSPAN_CXX_STD_17) +#define MDSPAN_HAS_CXX_20 (MDSPAN_IMPL_CPLUSPLUS >= MDSPAN_CXX_STD_20) +#define MDSPAN_HAS_CXX_23 (MDSPAN_IMPL_CPLUSPLUS >= MDSPAN_CXX_STD_23) -static_assert(_MDSPAN_CPLUSPLUS >= MDSPAN_CXX_STD_14, "mdspan requires C++14 or later."); +static_assert(MDSPAN_IMPL_CPLUSPLUS >= MDSPAN_CXX_STD_14, "mdspan requires C++14 or later."); -#ifndef _MDSPAN_COMPILER_CLANG +#ifndef MDSPAN_IMPL_COMPILER_CLANG # if defined(__clang__) -# define _MDSPAN_COMPILER_CLANG __clang__ +# define MDSPAN_IMPL_COMPILER_CLANG __clang__ # endif #endif -#if !defined(_MDSPAN_COMPILER_MSVC) && !defined(_MDSPAN_COMPILER_MSVC_CLANG) +#if !defined(MDSPAN_IMPL_COMPILER_MSVC) && !defined(MDSPAN_IMPL_COMPILER_MSVC_CLANG) # if defined(_MSC_VER) -# if !defined(_MDSPAN_COMPILER_CLANG) -# define _MDSPAN_COMPILER_MSVC _MSC_VER +# if !defined(MDSPAN_IMPL_COMPILER_CLANG) +# define MDSPAN_IMPL_COMPILER_MSVC _MSC_VER # else -# define _MDSPAN_COMPILER_MSVC_CLANG _MSC_VER +# define MDSPAN_IMPL_COMPILER_MSVC_CLANG _MSC_VER # endif # endif #endif -#ifndef _MDSPAN_COMPILER_INTEL +#ifndef MDSPAN_IMPL_COMPILER_INTEL # ifdef __INTEL_COMPILER -# define _MDSPAN_COMPILER_INTEL __INTEL_COMPILER +# define MDSPAN_IMPL_COMPILER_INTEL __INTEL_COMPILER # endif #endif -#ifndef _MDSPAN_COMPILER_APPLECLANG +#ifndef MDSPAN_IMPL_COMPILER_APPLECLANG # ifdef __apple_build_version__ -# define _MDSPAN_COMPILER_APPLECLANG __apple_build_version__ +# define MDSPAN_IMPL_COMPILER_APPLECLANG __apple_build_version__ # endif #endif -#ifndef _MDSPAN_HAS_CUDA +#ifndef MDSPAN_IMPL_HAS_CUDA # if defined(__CUDACC__) -# define _MDSPAN_HAS_CUDA __CUDACC__ +# define MDSPAN_IMPL_HAS_CUDA __CUDACC__ # endif #endif -#ifndef _MDSPAN_HAS_HIP +#ifndef MDSPAN_IMPL_HAS_HIP # if defined(__HIPCC__) -# define _MDSPAN_HAS_HIP __HIPCC__ +# define MDSPAN_IMPL_HAS_HIP __HIPCC__ # endif #endif -#ifndef _MDSPAN_HAS_SYCL +#ifndef MDSPAN_IMPL_HAS_SYCL # if defined(SYCL_LANGUAGE_VERSION) -# define _MDSPAN_HAS_SYCL SYCL_LANGUAGE_VERSION +# define MDSPAN_IMPL_HAS_SYCL SYCL_LANGUAGE_VERSION # endif #endif -#ifndef __has_cpp_attribute -# define __has_cpp_attribute(x) 0 +#ifndef MDSPAN_IMPL_HAS_CPP_ATTRIBUTE +# ifndef __has_cpp_attribute +# define MDSPAN_IMPL_HAS_CPP_ATTRIBUTE(x) 0 +# else +# define MDSPAN_IMPL_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x) +# endif #endif -#ifndef _MDSPAN_PRESERVE_STANDARD_LAYOUT +#ifndef MDSPAN_IMPL_PRESERVE_STANDARD_LAYOUT // Preserve standard layout by default, but we're not removing the old version // that turns this off until we're sure this doesn't have an unreasonable cost // to the compiler or optimizer. -# define _MDSPAN_PRESERVE_STANDARD_LAYOUT 1 +# define MDSPAN_IMPL_PRESERVE_STANDARD_LAYOUT 1 #endif -#if !defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) -# if ((__has_cpp_attribute(no_unique_address) >= 201803L) && \ - (!defined(__NVCC__) || MDSPAN_HAS_CXX_20) && \ - (!defined(_MDSPAN_COMPILER_MSVC) || MDSPAN_HAS_CXX_20)) -# define _MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS 1 -# define _MDSPAN_NO_UNIQUE_ADDRESS [[no_unique_address]] +#if !defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) +# if ((MDSPAN_IMPL_HAS_CPP_ATTRIBUTE(no_unique_address) >= 201803L) && \ + (!defined(__NVCC__) || ((__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__ * 10 < 1290) && MDSPAN_HAS_CXX_20)) && \ + (!defined(MDSPAN_IMPL_COMPILER_MSVC) || MDSPAN_HAS_CXX_20)) +# define MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS 1 +# define MDSPAN_IMPL_NO_UNIQUE_ADDRESS [[no_unique_address]] # else -# define _MDSPAN_NO_UNIQUE_ADDRESS +# define MDSPAN_IMPL_NO_UNIQUE_ADDRESS # endif #endif // NVCC older than 11.6 chokes on the no-unique-address-emulation // so just pretend to use it (to avoid the full blown EBO workaround // which NVCC also doesn't like ...), and leave the macro empty -#ifndef _MDSPAN_NO_UNIQUE_ADDRESS +#ifndef MDSPAN_IMPL_NO_UNIQUE_ADDRESS # if defined(__NVCC__) -# define _MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS 1 -# define _MDSPAN_USE_FAKE_ATTRIBUTE_NO_UNIQUE_ADDRESS +# define MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS 1 +# define MDSPAN_IMPL_USE_FAKE_ATTRIBUTE_NO_UNIQUE_ADDRESS # endif -# define _MDSPAN_NO_UNIQUE_ADDRESS +# define MDSPAN_IMPL_NO_UNIQUE_ADDRESS #endif // AMDs HIP compiler seems to have issues with concepts // it pretends concepts exist, but doesn't ship #ifndef __HIPCC__ -#ifndef _MDSPAN_USE_CONCEPTS +#ifndef MDSPAN_IMPL_USE_CONCEPTS # if defined(__cpp_concepts) && __cpp_concepts >= 201507L -# define _MDSPAN_USE_CONCEPTS 1 +# define MDSPAN_IMPL_USE_CONCEPTS 1 # endif #endif #endif -#ifndef _MDSPAN_USE_FOLD_EXPRESSIONS +#ifndef MDSPAN_IMPL_USE_FOLD_EXPRESSIONS # if (defined(__cpp_fold_expressions) && __cpp_fold_expressions >= 201603L) \ || (!defined(__cpp_fold_expressions) && MDSPAN_HAS_CXX_17) -# define _MDSPAN_USE_FOLD_EXPRESSIONS 1 +# define MDSPAN_IMPL_USE_FOLD_EXPRESSIONS 1 # endif #endif -#ifndef _MDSPAN_USE_INLINE_VARIABLES +#ifndef MDSPAN_IMPL_USE_INLINE_VARIABLES # if defined(__cpp_inline_variables) && __cpp_inline_variables >= 201606L \ || (!defined(__cpp_inline_variables) && MDSPAN_HAS_CXX_17) -# define _MDSPAN_USE_INLINE_VARIABLES 1 +# define MDSPAN_IMPL_USE_INLINE_VARIABLES 1 # endif #endif -#ifndef _MDSPAN_NEEDS_TRAIT_VARIABLE_TEMPLATE_BACKPORTS +#ifndef MDSPAN_IMPL_NEEDS_TRAIT_VARIABLE_TEMPLATE_BACKPORTS # if (!(defined(__cpp_lib_type_trait_variable_templates) && __cpp_lib_type_trait_variable_templates >= 201510L) \ || !MDSPAN_HAS_CXX_17) -# if !(defined(_MDSPAN_COMPILER_APPLECLANG) && MDSPAN_HAS_CXX_17) -# define _MDSPAN_NEEDS_TRAIT_VARIABLE_TEMPLATE_BACKPORTS 1 +# if !(defined(MDSPAN_IMPL_COMPILER_APPLECLANG) && MDSPAN_HAS_CXX_17) +# define MDSPAN_IMPL_NEEDS_TRAIT_VARIABLE_TEMPLATE_BACKPORTS 1 # endif # endif #endif -#ifndef _MDSPAN_USE_VARIABLE_TEMPLATES +#ifndef MDSPAN_IMPL_USE_VARIABLE_TEMPLATES # if (defined(__cpp_variable_templates) && __cpp_variable_templates >= 201304 && MDSPAN_HAS_CXX_17) \ || (!defined(__cpp_variable_templates) && MDSPAN_HAS_CXX_17) -# define _MDSPAN_USE_VARIABLE_TEMPLATES 1 +# define MDSPAN_IMPL_USE_VARIABLE_TEMPLATES 1 # endif -#endif // _MDSPAN_USE_VARIABLE_TEMPLATES +#endif // MDSPAN_IMPL_USE_VARIABLE_TEMPLATES -#ifndef _MDSPAN_USE_CONSTEXPR_14 +#ifndef MDSPAN_IMPL_USE_CONSTEXPR_14 # if (defined(__cpp_constexpr) && __cpp_constexpr >= 201304) \ || (!defined(__cpp_constexpr) && MDSPAN_HAS_CXX_14) \ && (!(defined(__INTEL_COMPILER) && __INTEL_COMPILER <= 1700)) -# define _MDSPAN_USE_CONSTEXPR_14 1 +# define MDSPAN_IMPL_USE_CONSTEXPR_14 1 +# endif +#endif + +#ifndef MDSPAN_IMPL_USE_IF_CONSTEXPR_17 +# if (defined(__cpp_if_constexpr) && __cpp_if_constexpr >= 201606) \ + || (!defined(__cpp_constexpr) && MDSPAN_HAS_CXX_17) +# define MDSPAN_IMPL_USE_IF_CONSTEXPR_17 1 # endif #endif -#ifndef _MDSPAN_USE_INTEGER_SEQUENCE -# if defined(_MDSPAN_COMPILER_MSVC) +#ifndef MDSPAN_IMPL_USE_INTEGER_SEQUENCE_14 +# if defined(MDSPAN_IMPL_COMPILER_MSVC) # if (defined(__cpp_lib_integer_sequence) && __cpp_lib_integer_sequence >= 201304) -# define _MDSPAN_USE_INTEGER_SEQUENCE 1 +# define MDSPAN_IMPL_USE_INTEGER_SEQUENCE_14 1 # endif # endif #endif -#ifndef _MDSPAN_USE_INTEGER_SEQUENCE +#ifndef MDSPAN_IMPL_USE_INTEGER_SEQUENCE_14 # if (defined(__cpp_lib_integer_sequence) && __cpp_lib_integer_sequence >= 201304) \ || (!defined(__cpp_lib_integer_sequence) && MDSPAN_HAS_CXX_14) \ /* as far as I can tell, libc++ seems to think this is a C++11 feature... */ \ || (defined(__GLIBCXX__) && __GLIBCXX__ > 20150422 && __GNUC__ < 5 && !defined(__INTEL_CXX11_MODE__)) // several compilers lie about integer_sequence working properly unless the C++14 standard is used -# define _MDSPAN_USE_INTEGER_SEQUENCE 1 -# elif defined(_MDSPAN_COMPILER_APPLECLANG) && MDSPAN_HAS_CXX_14 +# define MDSPAN_IMPL_USE_INTEGER_SEQUENCE_14 1 +# elif defined(MDSPAN_IMPL_COMPILER_APPLECLANG) && MDSPAN_HAS_CXX_14 // appleclang seems to be missing the __cpp_lib_... macros, but doesn't seem to lie about C++14 making // integer_sequence work -# define _MDSPAN_USE_INTEGER_SEQUENCE 1 +# define MDSPAN_IMPL_USE_INTEGER_SEQUENCE_14 1 # endif #endif -#ifndef _MDSPAN_USE_RETURN_TYPE_DEDUCTION +#ifndef MDSPAN_IMPL_USE_RETURN_TYPE_DEDUCTION # if (defined(__cpp_return_type_deduction) && __cpp_return_type_deduction >= 201304) \ || (!defined(__cpp_return_type_deduction) && MDSPAN_HAS_CXX_14) -# define _MDSPAN_USE_RETURN_TYPE_DEDUCTION 1 +# define MDSPAN_IMPL_USE_RETURN_TYPE_DEDUCTION 1 # endif #endif -#ifndef _MDSPAN_USE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION +#ifndef MDSPAN_IMPL_USE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION # if (!defined(__NVCC__) || (__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__ * 10 >= 1170)) && \ ((defined(__cpp_deduction_guides) && __cpp_deduction_guides >= 201703) || \ (!defined(__cpp_deduction_guides) && MDSPAN_HAS_CXX_17)) -# define _MDSPAN_USE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION 1 +# define MDSPAN_IMPL_USE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION 1 # endif #endif -#ifndef _MDSPAN_USE_STANDARD_TRAIT_ALIASES +#ifndef MDSPAN_IMPL_USE_STANDARD_TRAIT_ALIASES # if (defined(__cpp_lib_transformation_trait_aliases) && __cpp_lib_transformation_trait_aliases >= 201304) \ || (!defined(__cpp_lib_transformation_trait_aliases) && MDSPAN_HAS_CXX_14) -# define _MDSPAN_USE_STANDARD_TRAIT_ALIASES 1 -# elif defined(_MDSPAN_COMPILER_APPLECLANG) && MDSPAN_HAS_CXX_14 +# define MDSPAN_IMPL_USE_STANDARD_TRAIT_ALIASES 1 +# elif defined(MDSPAN_IMPL_COMPILER_APPLECLANG) && MDSPAN_HAS_CXX_14 // appleclang seems to be missing the __cpp_lib_... macros, but doesn't seem to lie about C++14 -# define _MDSPAN_USE_STANDARD_TRAIT_ALIASES 1 +# define MDSPAN_IMPL_USE_STANDARD_TRAIT_ALIASES 1 # endif #endif -#ifndef _MDSPAN_DEFAULTED_CONSTRUCTORS_INHERITANCE_WORKAROUND +#ifndef MDSPAN_IMPL_DEFAULTED_CONSTRUCTORS_INHERITANCE_WORKAROUND # ifdef __GNUC__ # if __GNUC__ < 9 -# define _MDSPAN_DEFAULTED_CONSTRUCTORS_INHERITANCE_WORKAROUND 1 +# define MDSPAN_IMPL_DEFAULTED_CONSTRUCTORS_INHERITANCE_WORKAROUND 1 # endif # endif #endif @@ -242,7 +257,7 @@ static_assert(_MDSPAN_CPLUSPLUS >= MDSPAN_CXX_STD_14, "mdspan requires C++14 or # if defined(__cpp_multidimensional_subscript) // The following if/else is necessary to workaround a clang issue // relative to using a parameter pack inside a bracket operator in C++2b/C++23 mode -# if defined(_MDSPAN_COMPILER_CLANG) && \ +# if defined(MDSPAN_IMPL_COMPILER_CLANG) && \ ((__clang_major__ < 17) || \ (__clang_major__ == 17 && __clang_minor__ == 0 && \ __clang_patchlevel__ == 0)) @@ -264,27 +279,27 @@ static_assert(_MDSPAN_CPLUSPLUS >= MDSPAN_CXX_STD_14, "mdspan requires C++14 or #endif #if MDSPAN_USE_BRACKET_OPERATOR -# define __MDSPAN_OP(mds,...) mds[__VA_ARGS__] +# define MDSPAN_IMPL_OP(mds,...) mds[__VA_ARGS__] // Corentins demo compiler for subscript chokes on empty [] call, // though I believe the proposal supports it? #ifdef MDSPAN_NO_EMPTY_BRACKET_OPERATOR -# define __MDSPAN_OP0(mds) mds.accessor().access(mds.data_handle(),0) +# define MDSPAN_IMPL_OP0(mds) mds.accessor().access(mds.data_handle(),0) #else -# define __MDSPAN_OP0(mds) mds[] -#endif -# define __MDSPAN_OP1(mds, a) mds[a] -# define __MDSPAN_OP2(mds, a, b) mds[a,b] -# define __MDSPAN_OP3(mds, a, b, c) mds[a,b,c] -# define __MDSPAN_OP4(mds, a, b, c, d) mds[a,b,c,d] -# define __MDSPAN_OP5(mds, a, b, c, d, e) mds[a,b,c,d,e] -# define __MDSPAN_OP6(mds, a, b, c, d, e, f) mds[a,b,c,d,e,f] +# define MDSPAN_IMPL_OP0(mds) mds[] +#endif +# define MDSPAN_IMPL_OP1(mds, a) mds[a] +# define MDSPAN_IMPL_OP2(mds, a, b) mds[a,b] +# define MDSPAN_IMPL_OP3(mds, a, b, c) mds[a,b,c] +# define MDSPAN_IMPL_OP4(mds, a, b, c, d) mds[a,b,c,d] +# define MDSPAN_IMPL_OP5(mds, a, b, c, d, e) mds[a,b,c,d,e] +# define MDSPAN_IMPL_OP6(mds, a, b, c, d, e, f) mds[a,b,c,d,e,f] #else -# define __MDSPAN_OP(mds,...) mds(__VA_ARGS__) -# define __MDSPAN_OP0(mds) mds() -# define __MDSPAN_OP1(mds, a) mds(a) -# define __MDSPAN_OP2(mds, a, b) mds(a,b) -# define __MDSPAN_OP3(mds, a, b, c) mds(a,b,c) -# define __MDSPAN_OP4(mds, a, b, c, d) mds(a,b,c,d) -# define __MDSPAN_OP5(mds, a, b, c, d, e) mds(a,b,c,d,e) -# define __MDSPAN_OP6(mds, a, b, c, d, e, f) mds(a,b,c,d,e,f) +# define MDSPAN_IMPL_OP(mds,...) mds(__VA_ARGS__) +# define MDSPAN_IMPL_OP0(mds) mds() +# define MDSPAN_IMPL_OP1(mds, a) mds(a) +# define MDSPAN_IMPL_OP2(mds, a, b) mds(a,b) +# define MDSPAN_IMPL_OP3(mds, a, b, c) mds(a,b,c) +# define MDSPAN_IMPL_OP4(mds, a, b, c, d) mds(a,b,c,d) +# define MDSPAN_IMPL_OP5(mds, a, b, c, d, e) mds(a,b,c,d,e) +# define MDSPAN_IMPL_OP6(mds, a, b, c, d, e, f) mds(a,b,c,d,e,f) #endif diff --git a/ext/mdspan/include/experimental/__p0009_bits/default_accessor.hpp b/ext/mdspan/include/experimental/__p0009_bits/default_accessor.hpp index ea0f537..b858fba 100644 --- a/ext/mdspan/include/experimental/__p0009_bits/default_accessor.hpp +++ b/ext/mdspan/include/experimental/__p0009_bits/default_accessor.hpp @@ -34,7 +34,7 @@ struct default_accessor { MDSPAN_TEMPLATE_REQUIRES( class OtherElementType, /* requires */ ( - _MDSPAN_TRAIT(std::is_convertible, OtherElementType(*)[], element_type(*)[]) + MDSPAN_IMPL_TRAIT(std::is_convertible, OtherElementType(*)[], element_type(*)[]) ) ) MDSPAN_INLINE_FUNCTION diff --git a/ext/mdspan/include/experimental/__p0009_bits/dynamic_extent.hpp b/ext/mdspan/include/experimental/__p0009_bits/dynamic_extent.hpp index 2e29da1..ffa4a6b 100644 --- a/ext/mdspan/include/experimental/__p0009_bits/dynamic_extent.hpp +++ b/ext/mdspan/include/experimental/__p0009_bits/dynamic_extent.hpp @@ -28,7 +28,7 @@ namespace MDSPAN_IMPL_STANDARD_NAMESPACE { #if defined(__cpp_lib_span) using std::dynamic_extent; #else -_MDSPAN_INLINE_VARIABLE constexpr auto dynamic_extent = std::numeric_limits::max(); +MDSPAN_IMPL_INLINE_VARIABLE constexpr auto dynamic_extent = std::numeric_limits::max(); #endif } // namespace MDSPAN_IMPL_STANDARD_NAMESPACE diff --git a/ext/mdspan/include/experimental/__p0009_bits/extents.hpp b/ext/mdspan/include/experimental/__p0009_bits/extents.hpp index d58d377..ab10ba3 100644 --- a/ext/mdspan/include/experimental/__p0009_bits/extents.hpp +++ b/ext/mdspan/include/experimental/__p0009_bits/extents.hpp @@ -34,7 +34,7 @@ namespace detail { // can't be a private member function for some reason. template MDSPAN_INLINE_FUNCTION -static constexpr std::integral_constant __check_compatible_extents( +constexpr std::integral_constant impl_check_compatible_extents( std::integral_constant, std::integer_sequence, std::integer_sequence) noexcept { @@ -43,7 +43,7 @@ static constexpr std::integral_constant __check_compatible_extents( // This helper prevents ICE's on MSVC. template -struct __compare_extent_compatible : std::integral_constant @@ -51,9 +51,9 @@ struct __compare_extent_compatible : std::integral_constant MDSPAN_INLINE_FUNCTION -static constexpr std::integral_constant< - bool, _MDSPAN_FOLD_AND(__compare_extent_compatible::value)> -__check_compatible_extents( +constexpr std::integral_constant< + bool, MDSPAN_IMPL_FOLD_AND(impl_compare_extent_compatible::value)> +impl_check_compatible_extents( std::integral_constant, std::integer_sequence, std::integer_sequence) noexcept { @@ -62,10 +62,10 @@ __check_compatible_extents( template MDSPAN_INLINE_FUNCTION -static constexpr bool are_valid_indices() { +constexpr bool are_valid_indices() { return - _MDSPAN_FOLD_AND(std::is_convertible::value) && - _MDSPAN_FOLD_AND(std::is_nothrow_constructible::value); + MDSPAN_IMPL_FOLD_AND(std::is_convertible::value) && + MDSPAN_IMPL_FOLD_AND(std::is_nothrow_constructible::value); } // ------------------------------------------------------------------ @@ -154,7 +154,7 @@ struct index_sequence_scan_impl { template struct index_sequence_scan_impl { #if defined(__NVCC__) || defined(__NVCOMPILER) || \ - defined(_MDSPAN_COMPILER_INTEL) + defined(MDSPAN_IMPL_COMPILER_INTEL) // NVCC warns about pointless comparison with 0 for R==0 and r being const // evaluatable and also 0. MDSPAN_INLINE_FUNCTION @@ -214,10 +214,10 @@ private: using static_vals_t = static_array; constexpr static size_t m_size = sizeof...(Values); constexpr static size_t m_size_dynamic = - _MDSPAN_FOLD_PLUS_RIGHT((Values == dyn_tag), 0); + MDSPAN_IMPL_FOLD_PLUS_RIGHT((Values == dyn_tag), 0); // Dynamic values member - _MDSPAN_NO_UNIQUE_ADDRESS possibly_empty_array + MDSPAN_IMPL_NO_UNIQUE_ADDRESS possibly_empty_array m_dyn_vals; // static mapping of indices to the position in the dynamic values array @@ -294,7 +294,7 @@ public: m_dyn_vals[dyn_map_t::get(r)] = values[r]; } // Precondition check -#ifdef _MDSPAN_DEBUG +#ifdef MDSPAN_DEBUG else { assert(values[r] == static_cast(static_val)); } @@ -309,7 +309,7 @@ public: constexpr maybe_static_array(const std::array &vals) { static_assert((N == m_size), "Invalid number of values."); // Precondition check -#ifdef _MDSPAN_DEBUG +#ifdef MDSPAN_DEBUG assert(N == m_size); #endif for (size_t r = 0; r < m_size; r++) { @@ -318,7 +318,7 @@ public: m_dyn_vals[dyn_map_t::get(r)] = static_cast(vals[r]); } // Precondition check -#ifdef _MDSPAN_DEBUG +#ifdef MDSPAN_DEBUG else { assert(static_cast(vals[r]) == static_cast(static_val)); @@ -334,7 +334,7 @@ public: MDSPAN_INLINE_FUNCTION constexpr maybe_static_array(const std::span &vals) { static_assert((N == m_size) || (m_size == dynamic_extent)); -#ifdef _MDSPAN_DEBUG +#ifdef MDSPAN_DEBUG assert(N == m_size); #endif for (size_t r = 0; r < m_size; r++) { @@ -342,7 +342,7 @@ public: if (static_val == dyn_tag) { m_dyn_vals[dyn_map_t::get(r)] = static_cast(vals[r]); } -#ifdef _MDSPAN_DEBUG +#ifdef MDSPAN_DEBUG else { assert(static_cast(vals[r]) == static_cast(static_val)); @@ -359,8 +359,11 @@ public: MDSPAN_INLINE_FUNCTION constexpr TDynamic value(size_t r) const { TStatic static_val = static_vals_t::get(r); - return static_val == dyn_tag ? m_dyn_vals[dyn_map_t::get(r)] - : static_cast(static_val); + + // FIXME: workaround for nvhpc OpenACC compiler bug + TStatic dyn_tag_copy = dyn_tag; + return static_val == dyn_tag_copy ? m_dyn_vals[dyn_map_t::get(r)] + : static_cast(static_val); } MDSPAN_INLINE_FUNCTION constexpr TDynamic operator[](size_t r) const { return value(r); } @@ -398,12 +401,12 @@ public: private: constexpr static rank_type m_rank = sizeof...(Extents); constexpr static rank_type m_rank_dynamic = - _MDSPAN_FOLD_PLUS_RIGHT((Extents == dynamic_extent), /* + ... + */ 0); + MDSPAN_IMPL_FOLD_PLUS_RIGHT((Extents == dynamic_extent), /* + ... + */ 0); // internal storage type using maybe_static_array using vals_t = detail::maybe_static_array; - _MDSPAN_NO_UNIQUE_ADDRESS vals_t m_vals; + MDSPAN_IMPL_NO_UNIQUE_ADDRESS vals_t m_vals; public: // [mdspan.extents.obs], observers of multidimensional index space @@ -428,9 +431,9 @@ public: MDSPAN_TEMPLATE_REQUIRES( class... OtherIndexTypes, /* requires */ ( - _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(std::is_convertible, OtherIndexTypes, + MDSPAN_IMPL_FOLD_AND(MDSPAN_IMPL_TRAIT(std::is_convertible, OtherIndexTypes, index_type) /* && ... */) && - _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(std::is_nothrow_constructible, index_type, + MDSPAN_IMPL_FOLD_AND(MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, index_type, OtherIndexTypes) /* && ... */) && (sizeof...(OtherIndexTypes) == m_rank || sizeof...(OtherIndexTypes) == m_rank_dynamic))) @@ -442,8 +445,8 @@ public: class OtherIndexType, size_t N, /* requires */ ( - _MDSPAN_TRAIT(std::is_convertible, const OtherIndexType&, index_type) && - _MDSPAN_TRAIT(std::is_nothrow_constructible, index_type, + MDSPAN_IMPL_TRAIT(std::is_convertible, const OtherIndexType&, index_type) && + MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, index_type, const OtherIndexType&) && (N == m_rank || N == m_rank_dynamic))) MDSPAN_INLINE_FUNCTION @@ -455,8 +458,8 @@ public: MDSPAN_TEMPLATE_REQUIRES( class OtherIndexType, size_t N, /* requires */ - (_MDSPAN_TRAIT(std::is_convertible, const OtherIndexType&, index_type) && - _MDSPAN_TRAIT(std::is_nothrow_constructible, index_type, const OtherIndexType&) && + (MDSPAN_IMPL_TRAIT(std::is_convertible, const OtherIndexType&, index_type) && + MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, index_type, const OtherIndexType&) && (N == m_rank || N == m_rank_dynamic))) MDSPAN_INLINE_FUNCTION MDSPAN_CONDITIONAL_EXPLICIT(N != m_rank_dynamic) @@ -474,11 +477,11 @@ private: /* requires */ ((R < m_rank) && (static_extent(R) == dynamic_extent))) MDSPAN_INLINE_FUNCTION constexpr - vals_t __construct_vals_from_extents(std::integral_constant, + vals_t impl_construct_vals_from_extents(std::integral_constant, std::integral_constant, const OtherExtents &exts, DynamicValues... dynamic_values) noexcept { - return __construct_vals_from_extents( + return impl_construct_vals_from_extents( std::integral_constant(), std::integral_constant(), exts, dynamic_values..., exts.extent(R)); @@ -489,11 +492,11 @@ private: /* requires */ ((R < m_rank) && (static_extent(R) != dynamic_extent))) MDSPAN_INLINE_FUNCTION constexpr - vals_t __construct_vals_from_extents(std::integral_constant, + vals_t impl_construct_vals_from_extents(std::integral_constant, std::integral_constant, const OtherExtents &exts, DynamicValues... dynamic_values) noexcept { - return __construct_vals_from_extents( + return impl_construct_vals_from_extents( std::integral_constant(), std::integral_constant(), exts, dynamic_values...); } @@ -503,7 +506,7 @@ private: /* requires */ ((R == m_rank) && (DynCount == m_rank_dynamic))) MDSPAN_INLINE_FUNCTION constexpr - vals_t __construct_vals_from_extents(std::integral_constant, + vals_t impl_construct_vals_from_extents(std::integral_constant, std::integral_constant, const OtherExtents &, DynamicValues... dynamic_values) noexcept { @@ -519,7 +522,7 @@ public: ( /* multi-stage check to protect from invalid pack expansion when sizes don't match? */ - decltype(detail::__check_compatible_extents( + decltype(detail::impl_check_compatible_extents( // using: sizeof...(Extents) == sizeof...(OtherExtents) as the second argument fails with MSVC+NVCC with some obscure expansion error // MSVC: 19.38.33133 NVCC: 12.0 std::integral_constant::rank() == extents::rank()>{}, @@ -534,7 +537,7 @@ public: (std::numeric_limits::max() < std::numeric_limits::max())) constexpr extents(const extents &other) noexcept - : m_vals(__construct_vals_from_extents( + : m_vals(impl_construct_vals_from_extents( std::integral_constant(), std::integral_constant(), other)) {} @@ -563,13 +566,13 @@ namespace detail { template > -struct __make_dextents; +struct impl_make_dextents; template -struct __make_dextents< +struct impl_make_dextents< IndexType, Rank, ::MDSPAN_IMPL_STANDARD_NAMESPACE::extents> { - using type = typename __make_dextents< + using type = typename impl_make_dextents< IndexType, Rank - 1, ::MDSPAN_IMPL_STANDARD_NAMESPACE::extents -struct __make_dextents< +struct impl_make_dextents< IndexType, 0, ::MDSPAN_IMPL_STANDARD_NAMESPACE::extents> { using type = ::MDSPAN_IMPL_STANDARD_NAMESPACE::extents; @@ -587,10 +590,10 @@ struct __make_dextents< // [mdspan.extents.dextents], alias template template -using dextents = typename detail::__make_dextents::type; +using dextents = typename detail::impl_make_dextents::type; // Deduction guide for extents -#if defined(_MDSPAN_USE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION) +#if defined(MDSPAN_IMPL_USE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION) template extents(IndexTypes...) -> extents struct __is_extents : ::std::false_type {}; +template struct impl_is_extents : ::std::false_type {}; template -struct __is_extents<::MDSPAN_IMPL_STANDARD_NAMESPACE::extents> +struct impl_is_extents<::MDSPAN_IMPL_STANDARD_NAMESPACE::extents> : ::std::true_type {}; template @@ -612,7 +615,7 @@ inline #else static #endif -constexpr bool __is_extents_v = __is_extents::value; +constexpr bool impl_is_extents_v = impl_is_extents::value; template MDSPAN_INLINE_FUNCTION @@ -622,7 +625,7 @@ check_lower_bound(InputIndexType user_index, std::true_type /* is_signed */) { (void) user_index; // prevent unused variable warning -#ifdef _MDSPAN_DEBUG +#ifdef MDSPAN_DEBUG assert(static_cast(user_index) >= 0); #endif } @@ -643,14 +646,14 @@ check_upper_bound(InputIndexType user_index, { (void) user_index; // prevent unused variable warnings (void) current_extent; -#ifdef _MDSPAN_DEBUG +#ifdef MDSPAN_DEBUG assert(static_cast(user_index) < current_extent); #endif } // Returning true to use AND fold instead of comma // CPP14 mode doesn't like the use of void expressions -// with the way the _MDSPAN_FOLD_AND is set up +// with the way the MDSPAN_IMPL_FOLD_AND is set up template MDSPAN_INLINE_FUNCTION constexpr bool @@ -673,7 +676,7 @@ check_all_indices_helper(std::index_sequence, Indices... indices) { // Suppress warning about statement has no effect - (void) _MDSPAN_FOLD_AND( + (void) MDSPAN_IMPL_FOLD_AND( (check_one_index(indices, exts.extent(RankIndices))) ); } diff --git a/ext/mdspan/include/experimental/__p0009_bits/full_extent_t.hpp b/ext/mdspan/include/experimental/__p0009_bits/full_extent_t.hpp index bd4b5c6..a1e296a 100644 --- a/ext/mdspan/include/experimental/__p0009_bits/full_extent_t.hpp +++ b/ext/mdspan/include/experimental/__p0009_bits/full_extent_t.hpp @@ -21,6 +21,6 @@ namespace MDSPAN_IMPL_STANDARD_NAMESPACE { struct full_extent_t { explicit full_extent_t() = default; }; -_MDSPAN_INLINE_VARIABLE constexpr auto full_extent = full_extent_t{ }; +MDSPAN_IMPL_INLINE_VARIABLE constexpr auto full_extent = full_extent_t{ }; } // namespace MDSPAN_IMPL_STANDARD_NAMESPACE diff --git a/ext/mdspan/include/experimental/__p0009_bits/layout_left.hpp b/ext/mdspan/include/experimental/__p0009_bits/layout_left.hpp index ed8aae0..e119800 100644 --- a/ext/mdspan/include/experimental/__p0009_bits/layout_left.hpp +++ b/ext/mdspan/include/experimental/__p0009_bits/layout_left.hpp @@ -39,7 +39,7 @@ class layout_left::mapping { using layout_type = layout_left; private: - static_assert(detail::__is_extents_v, + static_assert(detail::impl_is_extents_v, MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::layout_left::mapping must be instantiated with a specialization of " MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::extents."); template @@ -47,25 +47,25 @@ class layout_left::mapping { // i0+(i1 + E(1)*(i2 + E(2)*i3)) template - struct __rank_count {}; + struct rank_count {}; template - _MDSPAN_HOST_DEVICE - constexpr index_type __compute_offset( - __rank_count, const I& i, Indices... idx) const { - return __compute_offset(__rank_count(), idx...) * - __extents.extent(r) + i; + MDSPAN_IMPL_HOST_DEVICE + constexpr index_type compute_offset( + rank_count, const I& i, Indices... idx) const { + return compute_offset(rank_count(), idx...) * + m_extents.extent(r) + i; } template - _MDSPAN_HOST_DEVICE - constexpr index_type __compute_offset( - __rank_count, const I& i) const { + MDSPAN_IMPL_HOST_DEVICE + constexpr index_type compute_offset( + rank_count, const I& i) const { return i; } - _MDSPAN_HOST_DEVICE - constexpr index_type __compute_offset(__rank_count<0,0>) const { return 0; } + MDSPAN_IMPL_HOST_DEVICE + constexpr index_type compute_offset(rank_count<0,0>) const { return 0; } public: @@ -74,21 +74,21 @@ class layout_left::mapping { MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mapping() noexcept = default; MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mapping(mapping const&) noexcept = default; - _MDSPAN_HOST_DEVICE - constexpr mapping(extents_type const& __exts) noexcept - :__extents(__exts) + MDSPAN_IMPL_HOST_DEVICE + constexpr mapping(extents_type const& exts) noexcept + :m_extents(exts) { } MDSPAN_TEMPLATE_REQUIRES( class OtherExtents, /* requires */ ( - _MDSPAN_TRAIT(std::is_constructible, extents_type, OtherExtents) + MDSPAN_IMPL_TRAIT(std::is_constructible, extents_type, OtherExtents) ) ) MDSPAN_CONDITIONAL_EXPLICIT((!std::is_convertible::value)) // needs two () due to comma - MDSPAN_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 + MDSPAN_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 mapping(mapping const& other) noexcept // NOLINT(google-explicit-constructor) - :__extents(other.extents()) + :m_extents(other.extents()) { /* * TODO: check precondition @@ -99,14 +99,14 @@ class layout_left::mapping { MDSPAN_TEMPLATE_REQUIRES( class OtherExtents, /* requires */ ( - _MDSPAN_TRAIT(std::is_constructible, extents_type, OtherExtents) && + MDSPAN_IMPL_TRAIT(std::is_constructible, extents_type, OtherExtents) && (extents_type::rank() <= 1) ) ) MDSPAN_CONDITIONAL_EXPLICIT((!std::is_convertible::value)) // needs two () due to comma - MDSPAN_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 + MDSPAN_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 mapping(layout_right::mapping const& other) noexcept // NOLINT(google-explicit-constructor) - :__extents(other.extents()) + :m_extents(other.extents()) { /* * TODO: check precondition @@ -118,61 +118,62 @@ class layout_left::mapping { /** * Converting constructor from `layout_left_padded::mapping`. * - * This overload participates in overload resolution only if _Mapping is a layout_left_padded mapping and - * extents_type is constructible from _Mapping::extents_type. + * This overload participates in overload resolution only if Mapping is a layout_left_padded mapping and + * extents_type is constructible from Mapping::extents_type. * * \note There is currently a difference from p2642r2, where this function is specified as taking * `layout_left_padded< padding_value >::mapping< Extents>`. However, this makes `padding_value` non-deducible. */ MDSPAN_TEMPLATE_REQUIRES( - class _Mapping, + class Mapping, /* requires */ ( - MDSPAN_IMPL_PROPOSED_NAMESPACE::detail::is_layout_left_padded_mapping<_Mapping>::value - && std::is_constructible_v + MDSPAN_IMPL_PROPOSED_NAMESPACE::detail::is_layout_left_padded_mapping::value + && std::is_constructible_v ) ) - MDSPAN_CONDITIONAL_EXPLICIT((!std::is_convertible_v)) - mapping(const _Mapping& __other) noexcept - : __extents(__other.extents()) + MDSPAN_CONDITIONAL_EXPLICIT((!std::is_convertible_v)) + MDSPAN_INLINE_FUNCTION constexpr + mapping(const Mapping& other) noexcept + : m_extents(other.extents()) { MDSPAN_IMPL_PROPOSED_NAMESPACE::detail:: check_padded_layout_converting_constructor_mandates< - extents_type, _Mapping>(detail::with_rank{}); + extents_type, Mapping>(detail::with_rank{}); MDSPAN_IMPL_PROPOSED_NAMESPACE::detail:: check_padded_layout_converting_constructor_preconditions< - extents_type>(detail::with_rank{}, __other); + extents_type>(detail::with_rank{}, other); } #endif MDSPAN_TEMPLATE_REQUIRES( class OtherExtents, /* requires */ ( - _MDSPAN_TRAIT(std::is_constructible, extents_type, OtherExtents) + MDSPAN_IMPL_TRAIT(std::is_constructible, extents_type, OtherExtents) ) ) MDSPAN_CONDITIONAL_EXPLICIT((extents_type::rank() > 0)) - MDSPAN_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 + MDSPAN_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 mapping(layout_stride::mapping const& other) noexcept // NOLINT(google-explicit-constructor) - :__extents(other.extents()) + :m_extents(other.extents()) { /* * TODO: check precondition * other.required_span_size() is a representable value of type index_type */ - detail::validate_strides(detail::with_rank{}, layout_left{}, __extents, other); + detail::validate_strides(detail::with_rank{}, layout_left{}, m_extents, other); } - MDSPAN_INLINE_FUNCTION_DEFAULTED _MDSPAN_CONSTEXPR_14_DEFAULTED mapping& operator=(mapping const&) noexcept = default; + MDSPAN_INLINE_FUNCTION_DEFAULTED MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED mapping& operator=(mapping const&) noexcept = default; MDSPAN_INLINE_FUNCTION constexpr const extents_type& extents() const noexcept { - return __extents; + return m_extents; } MDSPAN_INLINE_FUNCTION constexpr index_type required_span_size() const noexcept { index_type value = 1; - for(rank_type r=0; r()) ) ) - _MDSPAN_HOST_DEVICE + MDSPAN_IMPL_HOST_DEVICE constexpr index_type operator()(Indices... idxs) const noexcept { #if ! defined(NDEBUG) detail::check_all_indices(this->extents(), idxs...); #endif // ! NDEBUG - return __compute_offset(__rank_count<0, extents_type::rank()>(), static_cast(idxs)...); + return compute_offset(rank_count<0, extents_type::rank()>(), static_cast(idxs)...); } @@ -210,7 +211,7 @@ class layout_left::mapping { #endif { index_type value = 1; - for(rank_type r=0; r MDSPAN_INLINE_FUNCTION - constexpr index_type __get_stride(MDSPAN_IMPL_STANDARD_NAMESPACE::extents,std::integer_sequence) const { - return _MDSPAN_FOLD_TIMES_RIGHT((Idx():1),1); + constexpr index_type impl_get_stride(MDSPAN_IMPL_STANDARD_NAMESPACE::extents,std::integer_sequence) const { + return MDSPAN_IMPL_FOLD_TIMES_RIGHT((Idx():1),1); } template MDSPAN_INLINE_FUNCTION - constexpr index_type __stride() const noexcept { - return __get_stride(__extents, std::make_index_sequence()); + constexpr index_type impl_stide() const noexcept { + return impl_get_stride(m_extents, std::make_index_sequence()); } private: - _MDSPAN_NO_UNIQUE_ADDRESS extents_type __extents{}; + MDSPAN_IMPL_NO_UNIQUE_ADDRESS extents_type m_extents{}; // [mdspan.submdspan.mapping], submdspan mapping specialization template @@ -266,4 +267,3 @@ private: } // end namespace MDSPAN_IMPL_STANDARD_NAMESPACE - diff --git a/ext/mdspan/include/experimental/__p0009_bits/layout_right.hpp b/ext/mdspan/include/experimental/__p0009_bits/layout_right.hpp index 26115e7..d95c180 100644 --- a/ext/mdspan/include/experimental/__p0009_bits/layout_right.hpp +++ b/ext/mdspan/include/experimental/__p0009_bits/layout_right.hpp @@ -37,7 +37,7 @@ class layout_right::mapping { using layout_type = layout_right; private: - static_assert(detail::__is_extents_v, + static_assert(detail::impl_is_extents_v, MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::layout_right::mapping must be instantiated with a specialization of " MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::extents."); template @@ -45,29 +45,29 @@ class layout_right::mapping { // i0+(i1 + E(1)*(i2 + E(2)*i3)) template - struct __rank_count {}; + struct rank_count {}; template - _MDSPAN_HOST_DEVICE - constexpr index_type __compute_offset( - index_type offset, __rank_count, const I& i, Indices... idx) const { - return __compute_offset(offset * __extents.extent(r) + i,__rank_count(), idx...); + MDSPAN_IMPL_HOST_DEVICE + constexpr index_type compute_offset( + index_type offset, rank_count, const I& i, Indices... idx) const { + return compute_offset(offset * m_extents.extent(r) + i,rank_count(), idx...); } template - _MDSPAN_HOST_DEVICE - constexpr index_type __compute_offset( - __rank_count<0,extents_type::rank()>, const I& i, Indices... idx) const { - return __compute_offset(i,__rank_count<1,extents_type::rank()>(),idx...); + MDSPAN_IMPL_HOST_DEVICE + constexpr index_type compute_offset( + rank_count<0,extents_type::rank()>, const I& i, Indices... idx) const { + return compute_offset(i,rank_count<1,extents_type::rank()>(),idx...); } - _MDSPAN_HOST_DEVICE - constexpr index_type __compute_offset(size_t offset, __rank_count) const { + MDSPAN_IMPL_HOST_DEVICE + constexpr index_type compute_offset(size_t offset, rank_count) const { return static_cast(offset); } - _MDSPAN_HOST_DEVICE - constexpr index_type __compute_offset(__rank_count<0,0>) const { return 0; } + MDSPAN_IMPL_HOST_DEVICE + constexpr index_type compute_offset(rank_count<0,0>) const { return 0; } public: @@ -76,21 +76,21 @@ class layout_right::mapping { MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mapping() noexcept = default; MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mapping(mapping const&) noexcept = default; - _MDSPAN_HOST_DEVICE - constexpr mapping(extents_type const& __exts) noexcept - :__extents(__exts) + MDSPAN_IMPL_HOST_DEVICE + constexpr mapping(extents_type const& exts) noexcept + :m_extents(exts) { } MDSPAN_TEMPLATE_REQUIRES( class OtherExtents, /* requires */ ( - _MDSPAN_TRAIT(std::is_constructible, extents_type, OtherExtents) + MDSPAN_IMPL_TRAIT(std::is_constructible, extents_type, OtherExtents) ) ) MDSPAN_CONDITIONAL_EXPLICIT((!std::is_convertible::value)) // needs two () due to comma - MDSPAN_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 + MDSPAN_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 mapping(mapping const& other) noexcept // NOLINT(google-explicit-constructor) - :__extents(other.extents()) + :m_extents(other.extents()) { /* * TODO: check precondition @@ -101,14 +101,14 @@ class layout_right::mapping { MDSPAN_TEMPLATE_REQUIRES( class OtherExtents, /* requires */ ( - _MDSPAN_TRAIT(std::is_constructible, extents_type, OtherExtents) && + MDSPAN_IMPL_TRAIT(std::is_constructible, extents_type, OtherExtents) && (extents_type::rank() <= 1) ) ) MDSPAN_CONDITIONAL_EXPLICIT((!std::is_convertible::value)) // needs two () due to comma - MDSPAN_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 + MDSPAN_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 mapping(layout_left::mapping const& other) noexcept // NOLINT(google-explicit-constructor) - :__extents(other.extents()) + :m_extents(other.extents()) { /* * TODO: check precondition @@ -119,60 +119,61 @@ class layout_right::mapping { /** * Converting constructor from `layout_right_padded::mapping`. * - * This overload participates in overload resolution only if _Mapping is a layout_right_padded mapping and - * extents_type is constructible from _Mapping::extents_type. + * This overload participates in overload resolution only if Mapping is a layout_right_padded mapping and + * extents_type is constructible from Mapping::extents_type. * * \note There is currently a difference from p2642r2, where this function is specified as taking * `layout_right_padded< padding_value >::mapping< Extents>`. However, this makes `padding_value` non-deducible. */ #if MDSPAN_HAS_CXX_17 MDSPAN_TEMPLATE_REQUIRES( - class _Mapping, + class Mapping, /* requires */ ( - MDSPAN_IMPL_PROPOSED_NAMESPACE::detail::is_layout_right_padded_mapping<_Mapping>::value - && std::is_constructible_v)) - MDSPAN_CONDITIONAL_EXPLICIT((!std::is_convertible_v)) - mapping(const _Mapping &__other) noexcept - : __extents(__other.extents()) + MDSPAN_IMPL_PROPOSED_NAMESPACE::detail::is_layout_right_padded_mapping::value + && std::is_constructible_v)) + MDSPAN_CONDITIONAL_EXPLICIT((!std::is_convertible_v)) + MDSPAN_INLINE_FUNCTION constexpr + mapping(const Mapping &other) noexcept + : m_extents(other.extents()) { MDSPAN_IMPL_PROPOSED_NAMESPACE::detail:: check_padded_layout_converting_constructor_mandates< - extents_type, _Mapping>(detail::with_rank{}); + extents_type, Mapping>(detail::with_rank{}); MDSPAN_IMPL_PROPOSED_NAMESPACE::detail:: check_padded_layout_converting_constructor_preconditions< - extents_type>(detail::with_rank{}, __other); + extents_type>(detail::with_rank{}, other); } #endif MDSPAN_TEMPLATE_REQUIRES( class OtherExtents, /* requires */ ( - _MDSPAN_TRAIT(std::is_constructible, extents_type, OtherExtents) + MDSPAN_IMPL_TRAIT(std::is_constructible, extents_type, OtherExtents) ) ) MDSPAN_CONDITIONAL_EXPLICIT((extents_type::rank() > 0)) - MDSPAN_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 + MDSPAN_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 mapping(layout_stride::mapping const& other) noexcept // NOLINT(google-explicit-constructor) - :__extents(other.extents()) + :m_extents(other.extents()) { /* * TODO: check precondition * other.required_span_size() is a representable value of type index_type */ - detail::validate_strides(detail::with_rank{}, layout_right{}, __extents, other); + detail::validate_strides(detail::with_rank{}, layout_right{}, m_extents, other); } - MDSPAN_INLINE_FUNCTION_DEFAULTED _MDSPAN_CONSTEXPR_14_DEFAULTED mapping& operator=(mapping const&) noexcept = default; + MDSPAN_INLINE_FUNCTION_DEFAULTED MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED mapping& operator=(mapping const&) noexcept = default; MDSPAN_INLINE_FUNCTION constexpr const extents_type& extents() const noexcept { - return __extents; + return m_extents; } MDSPAN_INLINE_FUNCTION constexpr index_type required_span_size() const noexcept { index_type value = 1; - for(rank_type r=0; r != extents_type::rank(); ++r) value*=__extents.extent(r); + for(rank_type r=0; r != extents_type::rank(); ++r) value*=m_extents.extent(r); return value; } @@ -185,12 +186,12 @@ class layout_right::mapping { (detail::are_valid_indices()) ) ) - _MDSPAN_HOST_DEVICE + MDSPAN_IMPL_HOST_DEVICE constexpr index_type operator()(Indices... idxs) const noexcept { #if ! defined(NDEBUG) detail::check_all_indices(this->extents(), idxs...); #endif // ! NDEBUG - return __compute_offset(__rank_count<0, extents_type::rank()>(), static_cast(idxs)...); + return compute_offset(rank_count<0, extents_type::rank()>(), static_cast(idxs)...); } MDSPAN_INLINE_FUNCTION static constexpr bool is_always_unique() noexcept { return true; } @@ -207,7 +208,7 @@ class layout_right::mapping { #endif { index_type value = 1; - for(rank_type r=extents_type::rank()-1; r>i; r--) value*=__extents.extent(r); + for(rank_type r=extents_type::rank()-1; r>i; r--) value*=m_extents.extent(r); return value; } @@ -235,17 +236,17 @@ class layout_right::mapping { // Not really public, but currently needed to implement fully constexpr useable submdspan: template MDSPAN_INLINE_FUNCTION - constexpr index_type __get_stride(MDSPAN_IMPL_STANDARD_NAMESPACE::extents,std::integer_sequence) const { - return _MDSPAN_FOLD_TIMES_RIGHT((Idx>N? __extents.template __extent():1),1); + constexpr index_type impl_get_stride(MDSPAN_IMPL_STANDARD_NAMESPACE::extents,std::integer_sequence) const { + return MDSPAN_IMPL_FOLD_TIMES_RIGHT((Idx>N? m_extents.template extent():1),1); } template MDSPAN_INLINE_FUNCTION - constexpr index_type __stride() const noexcept { - return __get_stride(__extents, std::make_index_sequence()); + constexpr index_type impl_stide() const noexcept { + return impl_get_stride(m_extents, std::make_index_sequence()); } private: - _MDSPAN_NO_UNIQUE_ADDRESS extents_type __extents{}; + MDSPAN_IMPL_NO_UNIQUE_ADDRESS extents_type m_extents{}; // [mdspan.submdspan.mapping], submdspan mapping specialization template @@ -262,4 +263,3 @@ private: }; } // end namespace MDSPAN_IMPL_STANDARD_NAMESPACE - diff --git a/ext/mdspan/include/experimental/__p0009_bits/layout_stride.hpp b/ext/mdspan/include/experimental/__p0009_bits/layout_stride.hpp index 47ef268..7f301a9 100644 --- a/ext/mdspan/include/experimental/__p0009_bits/layout_stride.hpp +++ b/ext/mdspan/include/experimental/__p0009_bits/layout_stride.hpp @@ -21,7 +21,7 @@ #include "compressed_pair.hpp" #include "utility.hpp" -#if !defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) +#if !defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) # include "no_unique_address.hpp" #endif @@ -32,7 +32,7 @@ #ifdef __cpp_lib_span #include #endif -#if defined(_MDSPAN_USE_CONCEPTS) && MDSPAN_HAS_CXX_20 && defined(__cpp_lib_concepts) +#if defined(MDSPAN_IMPL_USE_CONCEPTS) && MDSPAN_HAS_CXX_20 && defined(__cpp_lib_concepts) # include #endif @@ -48,33 +48,51 @@ struct layout_right { }; namespace detail { +#if MDSPAN_HAS_CXX_17 + using std::void_t; +#else + template using void_t = void; +#endif + // FIXME GCC <= 12: workaround gcc-12 bug that shows up in Kokkos; compilation fails when Mapping doesn't have + // extents_type. Normally this should just be a substitution failure, but causes an error with GCC <= 12 + // FIXME MSVC: I guess MSVC has a similar issue when it hits Layout::template mapping + template + struct is_mapping_of_impl : std::false_type {}; + + // FIXME GCC <= 12: We can't just do a conjunction of the two conditions, because the affected GCC versions seem to not + // short-circuit when resolving the substitution of Mapping + template + struct is_mapping_of_impl, void_t< typename Layout::template mapping >> + : std::is_same, Mapping> + {}; + template - constexpr bool __is_mapping_of = - std::is_same, Mapping>::value; + constexpr bool is_mapping_of = + is_mapping_of_impl::value; -#if defined(_MDSPAN_USE_CONCEPTS) && MDSPAN_HAS_CXX_20 +#if defined(MDSPAN_IMPL_USE_CONCEPTS) && MDSPAN_HAS_CXX_20 # if !defined(__cpp_lib_concepts) namespace internal { namespace detail { - template - concept __same_as = std::is_same_v<_Tp, _Up>; + template + concept same_as = std::is_same_v; } // namespace detail template - concept __same_as = detail::__same_as && detail::__same_as; + concept same_as = detail::same_as && detail::same_as; } // namespace internal # endif template - concept __layout_mapping_alike = requires { - requires __is_extents::value; + concept layout_mapping_alike = requires { + requires impl_is_extents::value; #if defined(__cpp_lib_concepts) { M::is_always_strided() } -> std::same_as; { M::is_always_exhaustive() } -> std::same_as; { M::is_always_unique() } -> std::same_as; #else - { M::is_always_strided() } -> internal::__same_as; - { M::is_always_exhaustive() } -> internal::__same_as; - { M::is_always_unique() } -> internal::__same_as; + { M::is_always_strided() } -> internal::same_as; + { M::is_always_exhaustive() } -> internal::same_as; + { M::is_always_unique() } -> internal::same_as; #endif std::bool_constant::value; std::bool_constant::value; @@ -87,9 +105,9 @@ namespace detail { struct layout_stride { template class mapping -#if !defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) - : private detail::__no_unique_address_emulation< - detail::__compressed_pair< +#if !defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) + : private detail::no_unique_address_emulation< + detail::impl_compressed_pair< Extents, detail::possibly_empty_array > @@ -104,7 +122,7 @@ struct layout_stride { using layout_type = layout_stride; // This could be a `requires`, but I think it's better and clearer as a `static_assert`. - static_assert(detail::__is_extents_v, + static_assert(detail::impl_is_extents_v, MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::layout_stride::mapping must be instantiated with a specialization of " MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::extents."); @@ -112,36 +130,36 @@ struct layout_stride { //---------------------------------------------------------------------------- - using __strides_storage_t = detail::possibly_empty_array; - using __member_pair_t = detail::__compressed_pair; + using strides_storage_t = detail::possibly_empty_array; + using member_pair_t = detail::impl_compressed_pair; -#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) - _MDSPAN_NO_UNIQUE_ADDRESS __member_pair_t __members; +#if defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) + MDSPAN_IMPL_NO_UNIQUE_ADDRESS member_pair_t m_members; #else - using __base_t = detail::__no_unique_address_emulation<__member_pair_t>; + using base_t = detail::no_unique_address_emulation; #endif - MDSPAN_FORCE_INLINE_FUNCTION constexpr __strides_storage_t const& - __strides_storage() const noexcept { -#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) - return __members.__second(); + MDSPAN_FORCE_INLINE_FUNCTION constexpr strides_storage_t const& + strides_storage() const noexcept { +#if defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) + return m_members.second(); #else - return this->__base_t::__ref().__second(); + return this->base_t::ref().second(); #endif } - MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 __strides_storage_t& - __strides_storage() noexcept { -#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) - return __members.__second(); + MDSPAN_FORCE_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 strides_storage_t& + strides_storage() noexcept { +#if defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) + return m_members.second(); #else - return this->__base_t::__ref().__second(); + return this->base_t::ref().second(); #endif } template - _MDSPAN_HOST_DEVICE - constexpr index_type __get_size(::MDSPAN_IMPL_STANDARD_NAMESPACE::extents,std::integer_sequence) const { - return _MDSPAN_FOLD_TIMES_RIGHT( static_cast(extents().extent(Idx)), 1 ); + MDSPAN_IMPL_HOST_DEVICE + constexpr index_type get_size(::MDSPAN_IMPL_STANDARD_NAMESPACE::extents,std::integer_sequence) const { + return MDSPAN_IMPL_FOLD_TIMES_RIGHT( static_cast(extents().extent(Idx)), 1 ); } //---------------------------------------------------------------------------- @@ -153,52 +171,52 @@ struct layout_stride { // Workaround for non-deducibility of the index sequence template parameter if it's given at the top level template - struct __deduction_workaround; + struct deduction_workaround; template - struct __deduction_workaround> + struct deduction_workaround> { template MDSPAN_INLINE_FUNCTION static constexpr bool _eq_impl(mapping const& self, mapping const& other) noexcept { using common_t = std::common_type_t; - return _MDSPAN_FOLD_AND((static_cast(self.stride(Idxs)) == static_cast(other.stride(Idxs))) /* && ... */) - && _MDSPAN_FOLD_AND((static_cast(self.extents().extent(Idxs)) == static_cast(other.extents().extent(Idxs))) /* || ... */); + return MDSPAN_IMPL_FOLD_AND((static_cast(self.stride(Idxs)) == static_cast(other.stride(Idxs))) /* && ... */) + && MDSPAN_IMPL_FOLD_AND((static_cast(self.extents().extent(Idxs)) == static_cast(other.extents().extent(Idxs))) /* || ... */); } template MDSPAN_INLINE_FUNCTION static constexpr bool _not_eq_impl(mapping const& self, mapping const& other) noexcept { using common_t = std::common_type_t; - return _MDSPAN_FOLD_OR((static_cast(self.stride(Idxs)) != static_cast(other.stride(Idxs))) /* || ... */) - || _MDSPAN_FOLD_OR((static_cast(self.extents().extent(Idxs)) != static_cast(other.extents().extent(Idxs))) /* || ... */); + return MDSPAN_IMPL_FOLD_OR((static_cast(self.stride(Idxs)) != static_cast(other.stride(Idxs))) /* || ... */) + || MDSPAN_IMPL_FOLD_OR((static_cast(self.extents().extent(Idxs)) != static_cast(other.extents().extent(Idxs))) /* || ... */); } template MDSPAN_FORCE_INLINE_FUNCTION static constexpr size_t _call_op_impl(mapping const& self, Integral... idxs) noexcept { - return _MDSPAN_FOLD_PLUS_RIGHT((idxs * self.stride(Idxs)), /* + ... + */ 0); + return MDSPAN_IMPL_FOLD_PLUS_RIGHT((idxs * self.stride(Idxs)), /* + ... + */ 0); } MDSPAN_INLINE_FUNCTION static constexpr size_t _req_span_size_impl(mapping const& self) noexcept { // assumes no negative strides; not sure if I'm allowed to assume that or not - return __impl::_call_op_impl(self, (self.extents().template __extent() - 1)...) + 1; + return deduction_workaround_impl::_call_op_impl(self, (self.extents().template extent() - 1)...) + 1; } template MDSPAN_INLINE_FUNCTION - static constexpr const __strides_storage_t fill_strides(const OtherMapping& map) { - return __strides_storage_t{static_cast(map.stride(Idxs))...}; + static constexpr const strides_storage_t fill_strides(const OtherMapping& map) { + return strides_storage_t{static_cast(map.stride(Idxs))...}; } MDSPAN_INLINE_FUNCTION - static constexpr const __strides_storage_t& fill_strides(const __strides_storage_t& s) { + static constexpr const strides_storage_t& fill_strides(const strides_storage_t& s) { return s; } template - static constexpr const __strides_storage_t fill_strides(const std::array& s) { - return __strides_storage_t{static_cast(s[Idxs])...}; + static constexpr const strides_storage_t fill_strides(const std::array& s) { + return strides_storage_t{static_cast(s[Idxs])...}; } MDSPAN_TEMPLATE_REQUIRES( @@ -207,44 +225,44 @@ struct layout_stride { ) MDSPAN_INLINE_FUNCTION // Need to avoid zero length c-array - static constexpr const __strides_storage_t fill_strides(mdspan_non_standard_tag, const IntegralType (&s)[extents_type::rank()>0?extents_type::rank():1]) { - return __strides_storage_t{static_cast(s[Idxs])...}; + static constexpr const strides_storage_t fill_strides(mdspan_non_standard_tag, const IntegralType (&s)[extents_type::rank()>0?extents_type::rank():1]) { + return strides_storage_t{static_cast(s[Idxs])...}; } #ifdef __cpp_lib_span template - static constexpr const __strides_storage_t fill_strides(const std::span& s) { - return __strides_storage_t{static_cast(s[Idxs])...}; + static constexpr const strides_storage_t fill_strides(const std::span& s) { + return strides_storage_t{static_cast(s[Idxs])...}; } #endif MDSPAN_INLINE_FUNCTION - static constexpr std::array return_strides(const __strides_storage_t& s) { + static constexpr std::array return_strides(const strides_storage_t& s) { return std::array{s[Idxs]...}; } template MDSPAN_INLINE_FUNCTION - static constexpr size_t __return_zero() { return 0; } + static constexpr size_t return_zero() { return 0; } template MDSPAN_INLINE_FUNCTION static constexpr typename Mapping::index_type - __OFFSET(const Mapping& m) { return m(__return_zero()...); } + offset(const Mapping& m) { return m(return_zero()...); } }; - // Can't use defaulted parameter in the __deduction_workaround template because of a bug in MSVC warning C4348. - using __impl = __deduction_workaround>; + // Can't use defaulted parameter in the deduction_workaround template because of a bug in MSVC warning C4348. + using deduction_workaround_impl = deduction_workaround>; MDSPAN_FUNCTION - static constexpr __strides_storage_t strides_storage(detail::with_rank<0>) { + static constexpr strides_storage_t strides_storage(detail::with_rank<0>) { return {}; } template MDSPAN_FUNCTION - static constexpr __strides_storage_t strides_storage(detail::with_rank) { - __strides_storage_t s{}; + static constexpr strides_storage_t strides_storage(detail::with_rank) { + strides_storage_t s{}; extents_type e; index_type stride = 1; @@ -258,12 +276,12 @@ struct layout_stride { //---------------------------------------------------------------------------- -#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) +#if defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) MDSPAN_INLINE_FUNCTION constexpr explicit - mapping(__member_pair_t&& __m) : __members(::std::move(__m)) {} + mapping(member_pair_t&& m) : m_members(::std::move(m)) {} #else MDSPAN_INLINE_FUNCTION constexpr explicit - mapping(__base_t&& __b) : __base_t(::std::move(__b)) {} + mapping(base_t&& __b) : base_t(::std::move(__b)) {} #endif public: @@ -271,14 +289,14 @@ struct layout_stride { //-------------------------------------------------------------------------------- MDSPAN_INLINE_FUNCTION constexpr mapping() noexcept -#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) - : __members{ +#if defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) + : m_members{ #else - : __base_t(__base_t{__member_pair_t( + : base_t(base_t{member_pair_t( #endif extents_type(), - __strides_storage_t(strides_storage(detail::with_rank{})) -#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) + strides_storage_t(strides_storage(detail::with_rank{})) +#if defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) } #else )}) @@ -292,8 +310,8 @@ struct layout_stride { /* requires */ ( // MSVC 19.32 does not like using index_type here, requires the typename Extents::index_type // error C2641: cannot deduce template arguments for 'MDSPAN_IMPL_STANDARD_NAMESPACE::layout_stride::mapping' - _MDSPAN_TRAIT(std::is_convertible, const std::remove_const_t&, typename Extents::index_type) && - _MDSPAN_TRAIT(std::is_nothrow_constructible, typename Extents::index_type, const std::remove_const_t&) + MDSPAN_IMPL_TRAIT(std::is_convertible, const std::remove_const_t&, typename Extents::index_type) && + MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, typename Extents::index_type, const std::remove_const_t&) ) ) constexpr @@ -301,13 +319,13 @@ struct layout_stride { extents_type const& e, std::array const& s ) noexcept -#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) - : __members{ +#if defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) + : m_members{ #else - : __base_t(__base_t{__member_pair_t( + : base_t(base_t{member_pair_t( #endif - e, __strides_storage_t(__impl::fill_strides(s)) -#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) + e, strides_storage_t(deduction_workaround_impl::fill_strides(s)) +#if defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) } #else )}) @@ -328,8 +346,8 @@ struct layout_stride { /* requires */ ( // MSVC 19.32 does not like using index_type here, requires the typename Extents::index_type // error C2641: cannot deduce template arguments for 'MDSPAN_IMPL_STANDARD_NAMESPACE::layout_stride::mapping' - _MDSPAN_TRAIT(std::is_convertible, const std::remove_const_t&, typename Extents::index_type) && - _MDSPAN_TRAIT(std::is_nothrow_constructible, typename Extents::index_type, const std::remove_const_t&) + MDSPAN_IMPL_TRAIT(std::is_convertible, const std::remove_const_t&, typename Extents::index_type) && + MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, typename Extents::index_type, const std::remove_const_t&) ) ) MDSPAN_INLINE_FUNCTION @@ -340,13 +358,13 @@ struct layout_stride { // Need to avoid zero-length c-array const IntegralTypes (&s)[extents_type::rank()>0?extents_type::rank():1] ) noexcept -#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) - : __members{ +#if defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) + : m_members{ #else - : __base_t(__base_t{__member_pair_t( + : base_t(base_t{member_pair_t( #endif - e, __strides_storage_t(__impl::fill_strides(mdspan_non_standard, s)) -#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) + e, strides_storage_t(deduction_workaround_impl::fill_strides(mdspan_non_standard, s)) +#if defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) } #else )}) @@ -368,8 +386,8 @@ struct layout_stride { /* requires */ ( // MSVC 19.32 does not like using index_type here, requires the typename Extents::index_type // error C2641: cannot deduce template arguments for 'MDSPAN_IMPL_STANDARD_NAMESPACE::layout_stride::mapping' - _MDSPAN_TRAIT(std::is_convertible, const std::remove_const_t&, typename Extents::index_type) && - _MDSPAN_TRAIT(std::is_nothrow_constructible, typename Extents::index_type, const std::remove_const_t&) + MDSPAN_IMPL_TRAIT(std::is_convertible, const std::remove_const_t&, typename Extents::index_type) && + MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, typename Extents::index_type, const std::remove_const_t&) ) ) constexpr @@ -377,13 +395,13 @@ struct layout_stride { extents_type const& e, std::span const& s ) noexcept -#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) - : __members{ +#if defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) + : m_members{ #else - : __base_t(__base_t{__member_pair_t( + : base_t(base_t{member_pair_t( #endif - e, __strides_storage_t(__impl::fill_strides(s)) -#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) + e, strides_storage_t(deduction_workaround_impl::fill_strides(s)) +#if defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) } #else )}) @@ -400,12 +418,12 @@ struct layout_stride { } #endif // __cpp_lib_span -#if !(defined(_MDSPAN_USE_CONCEPTS) && MDSPAN_HAS_CXX_20) +#if !(defined(MDSPAN_IMPL_USE_CONCEPTS) && MDSPAN_HAS_CXX_20) MDSPAN_TEMPLATE_REQUIRES( class StridedLayoutMapping, /* requires */ ( - _MDSPAN_TRAIT(std::is_constructible, extents_type, typename StridedLayoutMapping::extents_type) && - detail::__is_mapping_of && + MDSPAN_IMPL_TRAIT(std::is_constructible, extents_type, typename StridedLayoutMapping::extents_type) && + detail::is_mapping_of && StridedLayoutMapping::is_always_unique() && StridedLayoutMapping::is_always_strided() ) @@ -413,27 +431,27 @@ struct layout_stride { #else template requires( - detail::__layout_mapping_alike && - _MDSPAN_TRAIT(std::is_constructible, extents_type, typename StridedLayoutMapping::extents_type) && + detail::layout_mapping_alike && + MDSPAN_IMPL_TRAIT(std::is_constructible, extents_type, typename StridedLayoutMapping::extents_type) && StridedLayoutMapping::is_always_unique() && StridedLayoutMapping::is_always_strided() ) #endif MDSPAN_CONDITIONAL_EXPLICIT( !(std::is_convertible::value && - (detail::__is_mapping_of || - detail::__is_mapping_of || - detail::__is_mapping_of)) + (detail::is_mapping_of || + detail::is_mapping_of || + detail::is_mapping_of)) ) // needs two () due to comma - MDSPAN_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 + MDSPAN_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 mapping(StridedLayoutMapping const& other) noexcept // NOLINT(google-explicit-constructor) -#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) - : __members{ +#if defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) + : m_members{ #else - : __base_t(__base_t{__member_pair_t( + : base_t(base_t{member_pair_t( #endif - other.extents(), __strides_storage_t(__impl::fill_strides(other)) -#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) + other.extents(), strides_storage_t(deduction_workaround_impl::fill_strides(other)) +#if defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) } #else )}) @@ -449,20 +467,20 @@ struct layout_stride { //-------------------------------------------------------------------------------- - MDSPAN_INLINE_FUNCTION_DEFAULTED _MDSPAN_CONSTEXPR_14_DEFAULTED + MDSPAN_INLINE_FUNCTION_DEFAULTED MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED mapping& operator=(mapping const&) noexcept = default; MDSPAN_INLINE_FUNCTION constexpr const extents_type& extents() const noexcept { -#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) - return __members.__first(); +#if defined(MDSPAN_IMPL_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS) + return m_members.first(); #else - return this->__base_t::__ref().__first(); + return this->base_t::ref().first(); #endif - }; + } MDSPAN_INLINE_FUNCTION constexpr std::array< index_type, extents_type::rank() > strides() const noexcept { - return __impl::return_strides(__strides_storage()); + return deduction_workaround_impl::return_strides(strides_storage()); } MDSPAN_INLINE_FUNCTION @@ -472,7 +490,7 @@ struct layout_stride { for(int r = 0; r < static_cast(extents_type::rank()); r++) { // Return early if any of the extents are zero if(extents().extent(r)==0) return 0; - span_size += ( static_cast(extents().extent(r) - 1 ) * __strides_storage()[r]); + span_size += ( static_cast(extents().extent(r) - 1 ) * strides_storage()[r]); } return span_size; } @@ -490,7 +508,7 @@ struct layout_stride { #if ! defined(NDEBUG) detail::check_all_indices(this->extents(), idxs...); #endif // ! NDEBUG - return static_cast(__impl::_call_op_impl(*this, static_cast(idxs)...)); + return static_cast(deduction_workaround_impl::_call_op_impl(*this, static_cast(idxs)...)); } MDSPAN_INLINE_FUNCTION static constexpr bool is_always_unique() noexcept { return true; } @@ -505,7 +523,7 @@ struct layout_stride { MDSPAN_INLINE_FUNCTION constexpr bool exhaustive_for_nonzero_span_size() const { - return required_span_size() == __get_size(extents(), std::make_index_sequence()); + return required_span_size() == get_size(extents(), std::make_index_sequence()); } MDSPAN_INLINE_FUNCTION @@ -544,7 +562,7 @@ struct layout_stride { } public: - MDSPAN_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 bool is_exhaustive() const noexcept { + MDSPAN_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 bool is_exhaustive() const noexcept { return is_exhaustive_impl(detail::with_rank{}); } MDSPAN_INLINE_FUNCTION static constexpr bool is_strided() noexcept { return true; } @@ -552,14 +570,14 @@ struct layout_stride { MDSPAN_INLINE_FUNCTION constexpr index_type stride(rank_type r) const noexcept { - return __strides_storage()[r]; + return strides_storage()[r]; } -#if !(defined(_MDSPAN_USE_CONCEPTS) && MDSPAN_HAS_CXX_20) +#if !(defined(MDSPAN_IMPL_USE_CONCEPTS) && MDSPAN_HAS_CXX_20) MDSPAN_TEMPLATE_REQUIRES( class StridedLayoutMapping, /* requires */ ( - detail::__is_mapping_of && + detail::is_mapping_of && (extents_type::rank() == StridedLayoutMapping::extents_type::rank()) && StridedLayoutMapping::is_always_strided() ) @@ -567,7 +585,7 @@ struct layout_stride { #else template requires( - detail::__layout_mapping_alike && + detail::layout_mapping_alike && (extents_type::rank() == StridedLayoutMapping::extents_type::rank()) && StridedLayoutMapping::is_always_strided() ) @@ -575,7 +593,7 @@ struct layout_stride { MDSPAN_INLINE_FUNCTION friend constexpr bool operator==(const mapping& x, const StridedLayoutMapping& y) noexcept { return (x.extents() == y.extents()) && - (__impl::__OFFSET(y) == static_cast(0)) && + (deduction_workaround_impl::offset(y) == static_cast(0)) && detail::rankwise_equal(detail::with_rank{}, x, y, detail::stride); } @@ -588,14 +606,14 @@ struct layout_stride { ) MDSPAN_INLINE_FUNCTION friend constexpr bool operator==(mapping const& lhs, mapping const& rhs) noexcept { - return __impl::_eq_impl(lhs, rhs); + return deduction_workaround_impl::_eq_impl(lhs, rhs); } #if !MDSPAN_HAS_CXX_20 MDSPAN_TEMPLATE_REQUIRES( class StridedLayoutMapping, /* requires */ ( - detail::__is_mapping_of && + detail::is_mapping_of && (extents_type::rank() == StridedLayoutMapping::extents_type::rank()) && StridedLayoutMapping::is_always_strided() ) @@ -613,7 +631,7 @@ struct layout_stride { ) MDSPAN_INLINE_FUNCTION friend constexpr bool operator!=(mapping const& lhs, mapping const& rhs) noexcept { - return __impl::_not_eq_impl(lhs, rhs); + return deduction_workaround_impl::_not_eq_impl(lhs, rhs); } #endif diff --git a/ext/mdspan/include/experimental/__p0009_bits/macros.hpp b/ext/mdspan/include/experimental/__p0009_bits/macros.hpp index b60c426..7f288dc 100644 --- a/ext/mdspan/include/experimental/__p0009_bits/macros.hpp +++ b/ext/mdspan/include/experimental/__p0009_bits/macros.hpp @@ -21,36 +21,39 @@ #include #include #include // std::is_void -#if defined(_MDSPAN_HAS_CUDA) || defined(_MDSPAN_HAS_HIP) || defined(_MDSPAN_HAS_SYCL) +#if defined(MDSPAN_IMPL_HAS_SYCL) +#include // sycl::ext::oneapi::experimental::printf +#endif +#if defined(MDSPAN_IMPL_HAS_CUDA) || defined(MDSPAN_IMPL_HAS_HIP) || defined(MDSPAN_IMPL_HAS_SYCL) #include "assert.h" #endif -#ifndef _MDSPAN_HOST_DEVICE -# if defined(_MDSPAN_HAS_CUDA) || defined(_MDSPAN_HAS_HIP) -# define _MDSPAN_HOST_DEVICE __host__ __device__ +#ifndef MDSPAN_IMPL_HOST_DEVICE +# if defined(MDSPAN_IMPL_HAS_CUDA) || defined(MDSPAN_IMPL_HAS_HIP) +# define MDSPAN_IMPL_HOST_DEVICE __host__ __device__ # else -# define _MDSPAN_HOST_DEVICE +# define MDSPAN_IMPL_HOST_DEVICE # endif #endif #ifndef MDSPAN_FORCE_INLINE_FUNCTION -# ifdef _MDSPAN_COMPILER_MSVC // Microsoft compilers -# define MDSPAN_FORCE_INLINE_FUNCTION __forceinline _MDSPAN_HOST_DEVICE +# ifdef MDSPAN_IMPL_COMPILER_MSVC // Microsoft compilers +# define MDSPAN_FORCE_INLINE_FUNCTION __forceinline MDSPAN_IMPL_HOST_DEVICE # else -# define MDSPAN_FORCE_INLINE_FUNCTION __attribute__((always_inline)) _MDSPAN_HOST_DEVICE +# define MDSPAN_FORCE_INLINE_FUNCTION __attribute__((always_inline)) MDSPAN_IMPL_HOST_DEVICE # endif #endif #ifndef MDSPAN_INLINE_FUNCTION -# define MDSPAN_INLINE_FUNCTION inline _MDSPAN_HOST_DEVICE +# define MDSPAN_INLINE_FUNCTION inline MDSPAN_IMPL_HOST_DEVICE #endif #ifndef MDSPAN_FUNCTION -# define MDSPAN_FUNCTION _MDSPAN_HOST_DEVICE +# define MDSPAN_FUNCTION MDSPAN_IMPL_HOST_DEVICE #endif -#ifdef _MDSPAN_HAS_HIP -# define MDSPAN_DEDUCTION_GUIDE _MDSPAN_HOST_DEVICE +#ifdef MDSPAN_IMPL_HAS_HIP +# define MDSPAN_DEDUCTION_GUIDE MDSPAN_IMPL_HOST_DEVICE #else # define MDSPAN_DEDUCTION_GUIDE #endif @@ -64,15 +67,15 @@ // {{{1 #define MDSPAN_PP_COUNT(...) \ - _MDSPAN_PP_INTERNAL_EXPAND_ARGS_PRIVATE( \ - _MDSPAN_PP_INTERNAL_ARGS_AUGMENTER(__VA_ARGS__) \ + MDSPAN_IMPL_PP_INTERNAL_EXPAND_ARGS( \ + MDSPAN_IMPL_PP_INTERNAL_ARGS_AUGMENTER(__VA_ARGS__) \ ) -#define _MDSPAN_PP_INTERNAL_ARGS_AUGMENTER(...) unused, __VA_ARGS__ -#define _MDSPAN_PP_INTERNAL_EXPAND(x) x -#define _MDSPAN_PP_INTERNAL_EXPAND_ARGS_PRIVATE(...) \ - _MDSPAN_PP_INTERNAL_EXPAND( \ - _MDSPAN_PP_INTERNAL_COUNT_PRIVATE( \ +#define MDSPAN_IMPL_PP_INTERNAL_ARGS_AUGMENTER(...) unused, __VA_ARGS__ +#define MDSPAN_IMPL_PP_INTERNAL_EXPAND(x) x +#define MDSPAN_IMPL_PP_INTERNAL_EXPAND_ARGS(...) \ + MDSPAN_IMPL_PP_INTERNAL_EXPAND( \ + MDSPAN_IMPL_PP_INTERNAL_COUNT( \ __VA_ARGS__, 69, 68, 67, 66, 65, 64, 63, 62, 61, \ 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, \ 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, \ @@ -81,7 +84,7 @@ 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 \ ) \ ) -# define _MDSPAN_PP_INTERNAL_COUNT_PRIVATE( \ +# define MDSPAN_IMPL_PP_INTERNAL_COUNT( \ _1_, _2_, _3_, _4_, _5_, _6_, _7_, _8_, _9_, \ _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, \ _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, \ @@ -109,16 +112,22 @@ namespace MDSPAN_IMPL_STANDARD_NAMESPACE { namespace detail { -#if defined(_MDSPAN_HAS_CUDA) || defined(_MDSPAN_HAS_HIP) +#if defined(MDSPAN_IMPL_HAS_CUDA) || defined(MDSPAN_IMPL_HAS_HIP) MDSPAN_FUNCTION inline void default_precondition_violation_handler(const char* cond, const char* file, unsigned line) { - printf("%s:%u: precondition failure: `%s`\n", file, line, cond); + ::printf("%s:%u: precondition failure: `%s`\n", file, line, cond); assert(0); } -#elif defined(_MDSPAN_HAS_SYCL) +#elif defined(MDSPAN_IMPL_HAS_SYCL) MDSPAN_FUNCTION inline void default_precondition_violation_handler(const char* cond, const char* file, unsigned line) { +#ifdef __INTEL_LLVM_COMPILER sycl::ext::oneapi::experimental::printf("%s:%u: precondition failure: `%s`\n", file, line, cond); +#else + (void) cond; + (void) file; + (void) line; +#endif assert(0); } #else @@ -177,7 +186,7 @@ MDSPAN_FUNCTION constexpr void precondition(const char* cond, const char* file, // These compatibility macros don't help with partial ordering, but they should do the trick // for what we need to do with concepts in mdspan -#ifdef _MDSPAN_USE_CONCEPTS +#ifdef MDSPAN_IMPL_USE_CONCEPTS # define MDSPAN_CLOSE_ANGLE_REQUIRES(REQ) > requires REQ # define MDSPAN_FUNCTION_REQUIRES(PAREN_PREQUALS, FNAME, PAREN_PARAMS, QUALS, REQ) \ MDSPAN_PP_REMOVE_PARENS(PAREN_PREQUALS) FNAME PAREN_PARAMS QUALS requires REQ \ @@ -186,13 +195,13 @@ MDSPAN_FUNCTION constexpr void precondition(const char* cond, const char* file, # define MDSPAN_CLOSE_ANGLE_REQUIRES(REQ) , typename ::std::enable_if<(REQ), int>::type = 0> # define MDSPAN_FUNCTION_REQUIRES(PAREN_PREQUALS, FNAME, PAREN_PARAMS, QUALS, REQ) \ MDSPAN_TEMPLATE_REQUIRES( \ - class __function_requires_ignored=void, \ - (std::is_void<__function_requires_ignored>::value && REQ) \ + class function_requires_ignored=void, \ + (std::is_void::value && REQ) \ ) MDSPAN_PP_REMOVE_PARENS(PAREN_PREQUALS) FNAME PAREN_PARAMS QUALS \ /**/ #endif -#if defined(_MDSPAN_COMPILER_MSVC) && (!defined(_MSVC_TRADITIONAL) || _MSVC_TRADITIONAL) +#if defined(MDSPAN_IMPL_COMPILER_MSVC) && (!defined(_MSVC_TRADITIONAL) || _MSVC_TRADITIONAL) # define MDSPAN_TEMPLATE_REQUIRES(...) \ MDSPAN_PP_CAT( \ MDSPAN_PP_CAT(MDSPAN_TEMPLATE_REQUIRES_, MDSPAN_PP_COUNT(__VA_ARGS__))\ @@ -287,8 +296,8 @@ MDSPAN_FUNCTION constexpr void precondition(const char* cond, const char* file, #define MDSPAN_INSTANTIATE_ONLY_IF_USED \ MDSPAN_TEMPLATE_REQUIRES( \ - class __instantiate_only_if_used_tparam=void, \ - ( _MDSPAN_TRAIT(std::is_void, __instantiate_only_if_used_tparam) ) \ + class instantiate_only_if_used_tparam=void, \ + ( MDSPAN_IMPL_TRAIT(std::is_void, instantiate_only_if_used_tparam) ) \ ) \ /**/ @@ -298,10 +307,10 @@ MDSPAN_FUNCTION constexpr void precondition(const char* cond, const char* file, //============================================================================== // {{{1 -#ifdef _MDSPAN_USE_INLINE_VARIABLES -# define _MDSPAN_INLINE_VARIABLE inline +#ifdef MDSPAN_IMPL_USE_INLINE_VARIABLES +# define MDSPAN_IMPL_INLINE_VARIABLE inline #else -# define _MDSPAN_INLINE_VARIABLE +# define MDSPAN_IMPL_INLINE_VARIABLE #endif // end inline variables }}}1 @@ -310,17 +319,17 @@ MDSPAN_FUNCTION constexpr void precondition(const char* cond, const char* file, //============================================================================== // {{{1 -#if _MDSPAN_USE_RETURN_TYPE_DEDUCTION -# define _MDSPAN_DEDUCE_RETURN_TYPE_SINGLE_LINE(SIGNATURE, BODY) \ +#if MDSPAN_IMPL_USE_RETURN_TYPE_DEDUCTION +# define MDSPAN_IMPL_DEDUCE_RETURN_TYPE_SINGLE_LINE(SIGNATURE, BODY) \ auto MDSPAN_PP_REMOVE_PARENS(SIGNATURE) { return MDSPAN_PP_REMOVE_PARENS(BODY); } -# define _MDSPAN_DEDUCE_DECLTYPE_AUTO_RETURN_TYPE_SINGLE_LINE(SIGNATURE, BODY) \ +# define MDSPAN_IMPL_DEDUCE_DECLTYPE_AUTO_RETURN_TYPE_SINGLE_LINE(SIGNATURE, BODY) \ decltype(auto) MDSPAN_PP_REMOVE_PARENS(SIGNATURE) { return MDSPAN_PP_REMOVE_PARENS(BODY); } #else -# define _MDSPAN_DEDUCE_RETURN_TYPE_SINGLE_LINE(SIGNATURE, BODY) \ +# define MDSPAN_IMPL_DEDUCE_RETURN_TYPE_SINGLE_LINE(SIGNATURE, BODY) \ auto MDSPAN_PP_REMOVE_PARENS(SIGNATURE) \ -> std::remove_cv_t> \ { return MDSPAN_PP_REMOVE_PARENS(BODY); } -# define _MDSPAN_DEDUCE_DECLTYPE_AUTO_RETURN_TYPE_SINGLE_LINE(SIGNATURE, BODY) \ +# define MDSPAN_IMPL_DEDUCE_DECLTYPE_AUTO_RETURN_TYPE_SINGLE_LINE(SIGNATURE, BODY) \ auto MDSPAN_PP_REMOVE_PARENS(SIGNATURE) \ -> decltype(BODY) \ { return MDSPAN_PP_REMOVE_PARENS(BODY); } @@ -333,96 +342,96 @@ MDSPAN_FUNCTION constexpr void precondition(const char* cond, const char* file, //============================================================================== // {{{1 -struct __mdspan_enable_fold_comma { }; - -#ifdef _MDSPAN_USE_FOLD_EXPRESSIONS -# define _MDSPAN_FOLD_AND(...) ((__VA_ARGS__) && ...) -# define _MDSPAN_FOLD_AND_TEMPLATE(...) ((__VA_ARGS__) && ...) -# define _MDSPAN_FOLD_OR(...) ((__VA_ARGS__) || ...) -# define _MDSPAN_FOLD_ASSIGN_LEFT(INIT, ...) (INIT = ... = (__VA_ARGS__)) -# define _MDSPAN_FOLD_ASSIGN_RIGHT(PACK, ...) (PACK = ... = (__VA_ARGS__)) -# define _MDSPAN_FOLD_TIMES_RIGHT(PACK, ...) (PACK * ... * (__VA_ARGS__)) -# define _MDSPAN_FOLD_PLUS_RIGHT(PACK, ...) (PACK + ... + (__VA_ARGS__)) -# define _MDSPAN_FOLD_COMMA(...) ((__VA_ARGS__), ...) +struct enable_fold_comma { }; + +#ifdef MDSPAN_IMPL_USE_FOLD_EXPRESSIONS +# define MDSPAN_IMPL_FOLD_AND(...) ((__VA_ARGS__) && ...) +# define MDSPAN_IMPL_FOLD_AND_TEMPLATE(...) ((__VA_ARGS__) && ...) +# define MDSPAN_IMPL_FOLD_OR(...) ((__VA_ARGS__) || ...) +# define MDSPAN_IMPL_FOLD_ASSIGN_LEFT(INIT, ...) (INIT = ... = (__VA_ARGS__)) +# define MDSPAN_IMPL_FOLD_ASSIGN_RIGHT(PACK, ...) (PACK = ... = (__VA_ARGS__)) +# define MDSPAN_IMPL_FOLD_TIMES_RIGHT(PACK, ...) (PACK * ... * (__VA_ARGS__)) +# define MDSPAN_IMPL_FOLD_PLUS_RIGHT(PACK, ...) (PACK + ... + (__VA_ARGS__)) +# define MDSPAN_IMPL_FOLD_COMMA(...) ((__VA_ARGS__), ...) #else namespace MDSPAN_IMPL_STANDARD_NAMESPACE { -namespace __fold_compatibility_impl { +namespace fold_compatibility_impl { // We could probably be more clever here, but at the (small) risk of losing some compiler understanding. For the // few operations we need, it's not worth generalizing over the operation -#if _MDSPAN_USE_RETURN_TYPE_DEDUCTION +#if MDSPAN_IMPL_USE_RETURN_TYPE_DEDUCTION MDSPAN_FORCE_INLINE_FUNCTION -constexpr decltype(auto) __fold_right_and_impl() { +constexpr decltype(auto) fold_right_and_impl() { return true; } template MDSPAN_FORCE_INLINE_FUNCTION -constexpr decltype(auto) __fold_right_and_impl(Arg&& arg, Args&&... args) { - return ((Arg&&)arg) && __fold_compatibility_impl::__fold_right_and_impl((Args&&)args...); +constexpr decltype(auto) fold_right_and_impl(Arg&& arg, Args&&... args) { + return ((Arg&&)arg) && fold_compatibility_impl::fold_right_and_impl((Args&&)args...); } MDSPAN_FORCE_INLINE_FUNCTION -constexpr decltype(auto) __fold_right_or_impl() { +constexpr decltype(auto) fold_right_or_impl() { return false; } template MDSPAN_FORCE_INLINE_FUNCTION -constexpr auto __fold_right_or_impl(Arg&& arg, Args&&... args) { - return ((Arg&&)arg) || __fold_compatibility_impl::__fold_right_or_impl((Args&&)args...); +constexpr auto fold_right_or_impl(Arg&& arg, Args&&... args) { + return ((Arg&&)arg) || fold_compatibility_impl::fold_right_or_impl((Args&&)args...); } template MDSPAN_FORCE_INLINE_FUNCTION -constexpr auto __fold_left_assign_impl(Arg1&& arg1) { +constexpr auto fold_left_assign_impl(Arg1&& arg1) { return (Arg1&&)arg1; } template MDSPAN_FORCE_INLINE_FUNCTION -constexpr auto __fold_left_assign_impl(Arg1&& arg1, Arg2&& arg2, Args&&... args) { - return __fold_compatibility_impl::__fold_left_assign_impl((((Arg1&&)arg1) = ((Arg2&&)arg2)), (Args&&)args...); +constexpr auto fold_left_assign_impl(Arg1&& arg1, Arg2&& arg2, Args&&... args) { + return fold_compatibility_impl::fold_left_assign_impl((((Arg1&&)arg1) = ((Arg2&&)arg2)), (Args&&)args...); } template MDSPAN_FORCE_INLINE_FUNCTION -constexpr auto __fold_right_assign_impl(Arg1&& arg1) { +constexpr auto fold_right_assign_impl(Arg1&& arg1) { return (Arg1&&)arg1; } template MDSPAN_FORCE_INLINE_FUNCTION -constexpr auto __fold_right_assign_impl(Arg1&& arg1, Arg2&& arg2, Args&&... args) { - return ((Arg1&&)arg1) = __fold_compatibility_impl::__fold_right_assign_impl((Arg2&&)arg2, (Args&&)args...); +constexpr auto fold_right_assign_impl(Arg1&& arg1, Arg2&& arg2, Args&&... args) { + return ((Arg1&&)arg1) = fold_compatibility_impl::fold_right_assign_impl((Arg2&&)arg2, (Args&&)args...); } template MDSPAN_FORCE_INLINE_FUNCTION -constexpr auto __fold_right_plus_impl(Arg1&& arg1) { +constexpr auto fold_right_plus_impl(Arg1&& arg1) { return (Arg1&&)arg1; } template MDSPAN_FORCE_INLINE_FUNCTION -constexpr auto __fold_right_plus_impl(Arg1&& arg1, Arg2&& arg2, Args&&... args) { - return ((Arg1&&)arg1) + __fold_compatibility_impl::__fold_right_plus_impl((Arg2&&)arg2, (Args&&)args...); +constexpr auto fold_right_plus_impl(Arg1&& arg1, Arg2&& arg2, Args&&... args) { + return ((Arg1&&)arg1) + fold_compatibility_impl::fold_right_plus_impl((Arg2&&)arg2, (Args&&)args...); } template MDSPAN_FORCE_INLINE_FUNCTION -constexpr auto __fold_right_times_impl(Arg1&& arg1) { +constexpr auto fold_right_times_impl(Arg1&& arg1) { return (Arg1&&)arg1; } template MDSPAN_FORCE_INLINE_FUNCTION -constexpr auto __fold_right_times_impl(Arg1&& arg1, Arg2&& arg2, Args&&... args) { - return ((Arg1&&)arg1) * __fold_compatibility_impl::__fold_right_times_impl((Arg2&&)arg2, (Args&&)args...); +constexpr auto fold_right_times_impl(Arg1&& arg1, Arg2&& arg2, Args&&... args) { + return ((Arg1&&)arg1) * fold_compatibility_impl::fold_right_times_impl((Arg2&&)arg2, (Args&&)args...); } #else @@ -431,32 +440,32 @@ constexpr auto __fold_right_times_impl(Arg1&& arg1, Arg2&& arg2, Args&&... args) // {{{2 template -struct __fold_right_and_impl_; +struct fold_right_and_impl_; template <> -struct __fold_right_and_impl_<> { - using __rv = bool; +struct fold_right_and_impl_<> { + using rv = bool; MDSPAN_FORCE_INLINE_FUNCTION - static constexpr __rv - __impl() noexcept { + static constexpr rv + impl() noexcept { return true; } }; template -struct __fold_right_and_impl_ { - using __next_t = __fold_right_and_impl_; - using __rv = decltype(std::declval() && std::declval()); +struct fold_right_and_impl_ { + using next_t = fold_right_and_impl_; + using rv = decltype(std::declval() && std::declval()); MDSPAN_FORCE_INLINE_FUNCTION - static constexpr __rv - __impl(Arg&& arg, Args&&... args) noexcept { - return ((Arg&&)arg) && __next_t::__impl((Args&&)args...); + static constexpr rv + impl(Arg&& arg, Args&&... args) noexcept { + return ((Arg&&)arg) && next_t::impl((Args&&)args...); } }; template MDSPAN_FORCE_INLINE_FUNCTION -constexpr typename __fold_right_and_impl_::__rv -__fold_right_and_impl(Args&&... args) { - return __fold_right_and_impl_::__impl((Args&&)args...); +constexpr typename fold_right_and_impl_::rv +fold_right_and_impl(Args&&... args) { + return fold_right_and_impl_::impl((Args&&)args...); } // end right and }}}2 @@ -466,32 +475,32 @@ __fold_right_and_impl(Args&&... args) { // {{{2 template -struct __fold_right_or_impl_; +struct fold_right_or_impl_; template <> -struct __fold_right_or_impl_<> { - using __rv = bool; +struct fold_right_or_impl_<> { + using rv = bool; MDSPAN_FORCE_INLINE_FUNCTION - static constexpr __rv - __impl() noexcept { + static constexpr rv + impl() noexcept { return false; } }; template -struct __fold_right_or_impl_ { - using __next_t = __fold_right_or_impl_; - using __rv = decltype(std::declval() || std::declval()); +struct fold_right_or_impl_ { + using next_t = fold_right_or_impl_; + using rv = decltype(std::declval() || std::declval()); MDSPAN_FORCE_INLINE_FUNCTION - static constexpr __rv - __impl(Arg&& arg, Args&&... args) noexcept { - return ((Arg&&)arg) || __next_t::__impl((Args&&)args...); + static constexpr rv + impl(Arg&& arg, Args&&... args) noexcept { + return ((Arg&&)arg) || next_t::impl((Args&&)args...); } }; template MDSPAN_FORCE_INLINE_FUNCTION -constexpr typename __fold_right_or_impl_::__rv -__fold_right_or_impl(Args&&... args) { - return __fold_right_or_impl_::__impl((Args&&)args...); +constexpr typename fold_right_or_impl_::rv +fold_right_or_impl(Args&&... args) { + return fold_right_or_impl_::impl((Args&&)args...); } // end right or }}}2 @@ -501,32 +510,32 @@ __fold_right_or_impl(Args&&... args) { // {{{2 template -struct __fold_right_plus_impl_; +struct fold_right_plus_impl_; template -struct __fold_right_plus_impl_ { - using __rv = Arg&&; +struct fold_right_plus_impl_ { + using rv = Arg&&; MDSPAN_FORCE_INLINE_FUNCTION - static constexpr __rv - __impl(Arg&& arg) noexcept { + static constexpr rv + impl(Arg&& arg) noexcept { return (Arg&&)arg; } }; template -struct __fold_right_plus_impl_ { - using __next_t = __fold_right_plus_impl_; - using __rv = decltype(std::declval() + std::declval()); +struct fold_right_plus_impl_ { + using next_t = fold_right_plus_impl_; + using rv = decltype(std::declval() + std::declval()); MDSPAN_FORCE_INLINE_FUNCTION - static constexpr __rv - __impl(Arg1&& arg, Arg2&& arg2, Args&&... args) noexcept { - return ((Arg1&&)arg) + __next_t::__impl((Arg2&&)arg2, (Args&&)args...); + static constexpr rv + impl(Arg1&& arg, Arg2&& arg2, Args&&... args) noexcept { + return ((Arg1&&)arg) + next_t::impl((Arg2&&)arg2, (Args&&)args...); } }; template MDSPAN_FORCE_INLINE_FUNCTION -constexpr typename __fold_right_plus_impl_::__rv -__fold_right_plus_impl(Args&&... args) { - return __fold_right_plus_impl_::__impl((Args&&)args...); +constexpr typename fold_right_plus_impl_::rv +fold_right_plus_impl(Args&&... args) { + return fold_right_plus_impl_::impl((Args&&)args...); } // end right plus }}}2 @@ -536,32 +545,32 @@ __fold_right_plus_impl(Args&&... args) { // {{{2 template -struct __fold_right_times_impl_; +struct fold_right_times_impl_; template -struct __fold_right_times_impl_ { - using __rv = Arg&&; +struct fold_right_times_impl_ { + using rv = Arg&&; MDSPAN_FORCE_INLINE_FUNCTION - static constexpr __rv - __impl(Arg&& arg) noexcept { + static constexpr rv + impl(Arg&& arg) noexcept { return (Arg&&)arg; } }; template -struct __fold_right_times_impl_ { - using __next_t = __fold_right_times_impl_; - using __rv = decltype(std::declval() * std::declval()); +struct fold_right_times_impl_ { + using next_t = fold_right_times_impl_; + using rv = decltype(std::declval() * std::declval()); MDSPAN_FORCE_INLINE_FUNCTION - static constexpr __rv - __impl(Arg1&& arg, Arg2&& arg2, Args&&... args) noexcept { - return ((Arg1&&)arg) * __next_t::__impl((Arg2&&)arg2, (Args&&)args...); + static constexpr rv + impl(Arg1&& arg, Arg2&& arg2, Args&&... args) noexcept { + return ((Arg1&&)arg) * next_t::impl((Arg2&&)arg2, (Args&&)args...); } }; template MDSPAN_FORCE_INLINE_FUNCTION -constexpr typename __fold_right_times_impl_::__rv -__fold_right_times_impl(Args&&... args) { - return __fold_right_times_impl_::__impl((Args&&)args...); +constexpr typename fold_right_times_impl_::rv +fold_right_times_impl(Args&&... args) { + return fold_right_times_impl_::impl((Args&&)args...); } // end right times }}}2 @@ -571,32 +580,32 @@ __fold_right_times_impl(Args&&... args) { // {{{2 template -struct __fold_right_assign_impl_; +struct fold_right_assign_impl_; template -struct __fold_right_assign_impl_ { - using __rv = Arg&&; +struct fold_right_assign_impl_ { + using rv = Arg&&; MDSPAN_FORCE_INLINE_FUNCTION - static constexpr __rv - __impl(Arg&& arg) noexcept { + static constexpr rv + impl(Arg&& arg) noexcept { return (Arg&&)arg; } }; template -struct __fold_right_assign_impl_ { - using __next_t = __fold_right_assign_impl_; - using __rv = decltype(std::declval() = std::declval()); +struct fold_right_assign_impl_ { + using next_t = fold_right_assign_impl_; + using rv = decltype(std::declval() = std::declval()); MDSPAN_FORCE_INLINE_FUNCTION - static constexpr __rv - __impl(Arg1&& arg, Arg2&& arg2, Args&&... args) noexcept { - return ((Arg1&&)arg) = __next_t::__impl((Arg2&&)arg2, (Args&&)args...); + static constexpr rv + impl(Arg1&& arg, Arg2&& arg2, Args&&... args) noexcept { + return ((Arg1&&)arg) = next_t::impl((Arg2&&)arg2, (Args&&)args...); } }; template MDSPAN_FORCE_INLINE_FUNCTION -constexpr typename __fold_right_assign_impl_::__rv -__fold_right_assign_impl(Args&&... args) { - return __fold_right_assign_impl_::__impl((Args&&)args...); +constexpr typename fold_right_assign_impl_::rv +fold_right_assign_impl(Args&&... args) { + return fold_right_assign_impl_::impl((Args&&)args...); } // end right assign }}}2 @@ -606,33 +615,33 @@ __fold_right_assign_impl(Args&&... args) { // {{{2 template -struct __fold_left_assign_impl_; +struct fold_left_assign_impl_; template -struct __fold_left_assign_impl_ { - using __rv = Arg&&; +struct fold_left_assign_impl_ { + using rv = Arg&&; MDSPAN_FORCE_INLINE_FUNCTION - static constexpr __rv - __impl(Arg&& arg) noexcept { + static constexpr rv + impl(Arg&& arg) noexcept { return (Arg&&)arg; } }; template -struct __fold_left_assign_impl_ { - using __assign_result_t = decltype(std::declval() = std::declval()); - using __next_t = __fold_left_assign_impl_<__assign_result_t, Args...>; - using __rv = typename __next_t::__rv; +struct fold_left_assign_impl_ { + using assign_result_t = decltype(std::declval() = std::declval()); + using next_t = fold_left_assign_impl_; + using rv = typename next_t::rv; MDSPAN_FORCE_INLINE_FUNCTION - static constexpr __rv - __impl(Arg1&& arg, Arg2&& arg2, Args&&... args) noexcept { - return __next_t::__impl(((Arg1&&)arg) = (Arg2&&)arg2, (Args&&)args...); + static constexpr rv + impl(Arg1&& arg, Arg2&& arg2, Args&&... args) noexcept { + return next_t::impl(((Arg1&&)arg) = (Arg2&&)arg2, (Args&&)args...); } }; template MDSPAN_FORCE_INLINE_FUNCTION -constexpr typename __fold_left_assign_impl_::__rv -__fold_left_assign_impl(Args&&... args) { - return __fold_left_assign_impl_::__impl((Args&&)args...); +constexpr typename fold_left_assign_impl_::rv +fold_left_assign_impl(Args&&... args) { + return fold_left_assign_impl_::impl((Args&&)args...); } // end left assign }}}2 @@ -642,25 +651,25 @@ __fold_left_assign_impl(Args&&... args) { template -constexpr __mdspan_enable_fold_comma __fold_comma_impl(Args&&...) noexcept { return { }; } +constexpr enable_fold_comma fold_comma_impl(Args&&...) noexcept { return { }; } template -struct __bools; +struct fold_bools; -} // __fold_compatibility_impl +} // fold_compatibility_impl } // end namespace MDSPAN_IMPL_STANDARD_NAMESPACE -# define _MDSPAN_FOLD_AND(...) MDSPAN_IMPL_STANDARD_NAMESPACE::__fold_compatibility_impl::__fold_right_and_impl((__VA_ARGS__)...) -# define _MDSPAN_FOLD_OR(...) MDSPAN_IMPL_STANDARD_NAMESPACE::__fold_compatibility_impl::__fold_right_or_impl((__VA_ARGS__)...) -# define _MDSPAN_FOLD_ASSIGN_LEFT(INIT, ...) MDSPAN_IMPL_STANDARD_NAMESPACE::__fold_compatibility_impl::__fold_left_assign_impl(INIT, (__VA_ARGS__)...) -# define _MDSPAN_FOLD_ASSIGN_RIGHT(PACK, ...) MDSPAN_IMPL_STANDARD_NAMESPACE::__fold_compatibility_impl::__fold_right_assign_impl((PACK)..., __VA_ARGS__) -# define _MDSPAN_FOLD_TIMES_RIGHT(PACK, ...) MDSPAN_IMPL_STANDARD_NAMESPACE::__fold_compatibility_impl::__fold_right_times_impl((PACK)..., __VA_ARGS__) -# define _MDSPAN_FOLD_PLUS_RIGHT(PACK, ...) MDSPAN_IMPL_STANDARD_NAMESPACE::__fold_compatibility_impl::__fold_right_plus_impl((PACK)..., __VA_ARGS__) -# define _MDSPAN_FOLD_COMMA(...) MDSPAN_IMPL_STANDARD_NAMESPACE::__fold_compatibility_impl::__fold_comma_impl((__VA_ARGS__)...) +# define MDSPAN_IMPL_FOLD_AND(...) MDSPAN_IMPL_STANDARD_NAMESPACE::fold_compatibility_impl::fold_right_and_impl((__VA_ARGS__)...) +# define MDSPAN_IMPL_FOLD_OR(...) MDSPAN_IMPL_STANDARD_NAMESPACE::fold_compatibility_impl::fold_right_or_impl((__VA_ARGS__)...) +# define MDSPAN_IMPL_FOLD_ASSIGN_LEFT(INIT, ...) MDSPAN_IMPL_STANDARD_NAMESPACE::fold_compatibility_impl::fold_left_assign_impl(INIT, (__VA_ARGS__)...) +# define MDSPAN_IMPL_FOLD_ASSIGN_RIGHT(PACK, ...) MDSPAN_IMPL_STANDARD_NAMESPACE::fold_compatibility_impl::fold_right_assign_impl((PACK)..., __VA_ARGS__) +# define MDSPAN_IMPL_FOLD_TIMES_RIGHT(PACK, ...) MDSPAN_IMPL_STANDARD_NAMESPACE::fold_compatibility_impl::fold_right_times_impl((PACK)..., __VA_ARGS__) +# define MDSPAN_IMPL_FOLD_PLUS_RIGHT(PACK, ...) MDSPAN_IMPL_STANDARD_NAMESPACE::fold_compatibility_impl::fold_right_plus_impl((PACK)..., __VA_ARGS__) +# define MDSPAN_IMPL_FOLD_COMMA(...) MDSPAN_IMPL_STANDARD_NAMESPACE::fold_compatibility_impl::fold_comma_impl((__VA_ARGS__)...) -# define _MDSPAN_FOLD_AND_TEMPLATE(...) \ - _MDSPAN_TRAIT(std::is_same, __fold_compatibility_impl::__bools<(__VA_ARGS__)..., true>, __fold_compatibility_impl::__bools) +# define MDSPAN_IMPL_FOLD_AND_TEMPLATE(...) \ + MDSPAN_IMPL_TRAIT(std::is_same, fold_compatibility_impl::fold_bools<(__VA_ARGS__)..., true>, fold_compatibility_impl::fold_bools) #endif @@ -670,10 +679,10 @@ struct __bools; //============================================================================== // {{{1 -#if _MDSPAN_USE_VARIABLE_TEMPLATES -# define _MDSPAN_TRAIT(TRAIT, ...) TRAIT##_v<__VA_ARGS__> +#if MDSPAN_IMPL_USE_VARIABLE_TEMPLATES +# define MDSPAN_IMPL_TRAIT(TRAIT, ...) TRAIT##_v<__VA_ARGS__> #else -# define _MDSPAN_TRAIT(TRAIT, ...) TRAIT<__VA_ARGS__>::value +# define MDSPAN_IMPL_TRAIT(TRAIT, ...) TRAIT<__VA_ARGS__>::value #endif // end Variable template compatibility }}}1 @@ -682,18 +691,24 @@ struct __bools; //============================================================================== // {{{1 -#if _MDSPAN_USE_CONSTEXPR_14 -# define _MDSPAN_CONSTEXPR_14 constexpr +#if MDSPAN_IMPL_USE_CONSTEXPR_14 +# define MDSPAN_IMPL_CONSTEXPR_14 constexpr // Workaround for a bug (I think?) in EDG frontends # ifdef __EDG__ -# define _MDSPAN_CONSTEXPR_14_DEFAULTED +# define MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED # else -# define _MDSPAN_CONSTEXPR_14_DEFAULTED constexpr +# define MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED constexpr # endif #else -# define _MDSPAN_CONSTEXPR_14 -# define _MDSPAN_CONSTEXPR_14_DEFAULTED +# define MDSPAN_IMPL_CONSTEXPR_14 +# define MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED #endif // end Pre-C++14 constexpr }}}1 //============================================================================== + +#if MDSPAN_IMPL_USE_IF_CONSTEXPR_17 +# define MDSPAN_IMPL_IF_CONSTEXPR_17 constexpr +#else +# define MDSPAN_IMPL_IF_CONSTEXPR_17 +#endif diff --git a/ext/mdspan/include/experimental/__p0009_bits/mdspan.hpp b/ext/mdspan/include/experimental/__p0009_bits/mdspan.hpp index 23114aa..b4da258 100644 --- a/ext/mdspan/include/experimental/__p0009_bits/mdspan.hpp +++ b/ext/mdspan/include/experimental/__p0009_bits/mdspan.hpp @@ -18,10 +18,15 @@ #include "default_accessor.hpp" #include "layout_right.hpp" +#include "macros.hpp" #include "extents.hpp" #include "trait_backports.hpp" #include "compressed_pair.hpp" +#include +#include +#include + namespace MDSPAN_IMPL_STANDARD_NAMESPACE { template < class ElementType, @@ -32,36 +37,36 @@ template < class mdspan { private: - static_assert(detail::__is_extents_v, + static_assert(detail::impl_is_extents_v, MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::mdspan's Extents template parameter must be a specialization of " MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::extents."); static_assert(std::is_same::value, MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::mdspan's ElementType template parameter must be the same as its AccessorPolicy::element_type."); // Workaround for non-deducibility of the index sequence template parameter if it's given at the top level template - struct __deduction_workaround; + struct deduction_workaround; template - struct __deduction_workaround> + struct deduction_workaround> { MDSPAN_FORCE_INLINE_FUNCTION static constexpr - size_t __size(mdspan const& __self) noexcept { - return _MDSPAN_FOLD_TIMES_RIGHT((__self.__mapping_ref().extents().extent(Idxs)), /* * ... * */ size_t(1)); + size_t size(mdspan const& self) noexcept { + return MDSPAN_IMPL_FOLD_TIMES_RIGHT((self.mapping_ref().extents().extent(Idxs)), /* * ... * */ size_t(1)); } MDSPAN_FORCE_INLINE_FUNCTION static constexpr - bool __empty(mdspan const& __self) noexcept { - return (__self.rank()>0) && _MDSPAN_FOLD_OR((__self.__mapping_ref().extents().extent(Idxs)==index_type(0))); + bool empty(mdspan const& self) noexcept { + return (self.rank()>0) && MDSPAN_IMPL_FOLD_OR((self.mapping_ref().extents().extent(Idxs)==index_type(0))); } template MDSPAN_FORCE_INLINE_FUNCTION static constexpr - ReferenceType __callop(mdspan const& __self, const std::array& indices) noexcept { - return __self.__accessor_ref().access(__self.__ptr_ref(), __self.__mapping_ref()(indices[Idxs]...)); + ReferenceType callop(mdspan const& self, const std::array& indices) noexcept { + return self.accessor_ref().access(self.ptr_ref(), self.mapping_ref()(indices[Idxs]...)); } #ifdef __cpp_lib_span template MDSPAN_FORCE_INLINE_FUNCTION static constexpr - ReferenceType __callop(mdspan const& __self, const std::span& indices) noexcept { - return __self.__accessor_ref().access(__self.__ptr_ref(), __self.__mapping_ref()(indices[Idxs]...)); + ReferenceType callop(mdspan const& self, const std::span& indices) noexcept { + return self.accessor_ref().access(self.ptr_ref(), self.mapping_ref()(indices[Idxs]...)); } #endif }; @@ -83,17 +88,17 @@ public: using data_handle_type = typename accessor_type::data_handle_type; using reference = typename accessor_type::reference; - MDSPAN_INLINE_FUNCTION static constexpr size_t rank() noexcept { return extents_type::rank(); } - MDSPAN_INLINE_FUNCTION static constexpr size_t rank_dynamic() noexcept { return extents_type::rank_dynamic(); } + MDSPAN_INLINE_FUNCTION static constexpr rank_type rank() noexcept { return extents_type::rank(); } + MDSPAN_INLINE_FUNCTION static constexpr rank_type rank_dynamic() noexcept { return extents_type::rank_dynamic(); } MDSPAN_INLINE_FUNCTION static constexpr size_t static_extent(size_t r) noexcept { return extents_type::static_extent(r); } - MDSPAN_INLINE_FUNCTION constexpr index_type extent(size_t r) const noexcept { return __mapping_ref().extents().extent(r); }; + MDSPAN_INLINE_FUNCTION constexpr index_type extent(size_t r) const noexcept { return mapping_ref().extents().extent(r); } private: - // Can't use defaulted parameter in the __deduction_workaround template because of a bug in MSVC warning C4348. - using __impl = __deduction_workaround>; + // Can't use defaulted parameter in the deduction_workaround template because of a bug in MSVC warning C4348. + using deduction_workaround_impl = deduction_workaround>; - using __map_acc_pair_t = detail::__compressed_pair; + using map_acc_pair_t = detail::impl_compressed_pair; public: @@ -107,9 +112,9 @@ public: requires( // nvhpc has a bug where using just rank_dynamic() here doesn't work ... (extents_type::rank_dynamic() > 0) && - _MDSPAN_TRAIT(std::is_default_constructible, data_handle_type) && - _MDSPAN_TRAIT(std::is_default_constructible, mapping_type) && - _MDSPAN_TRAIT(std::is_default_constructible, accessor_type) + MDSPAN_IMPL_TRAIT(std::is_default_constructible, data_handle_type) && + MDSPAN_IMPL_TRAIT(std::is_default_constructible, mapping_type) && + MDSPAN_IMPL_TRAIT(std::is_default_constructible, accessor_type) ) = default; #endif MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mdspan(const mdspan&) = default; @@ -120,87 +125,87 @@ public: /* requires */ ( ((sizeof...(SizeTypes) == rank()) || (sizeof...(SizeTypes) == rank_dynamic())) && (detail::are_valid_indices()) && - _MDSPAN_TRAIT(std::is_constructible, mapping_type, extents_type) && - _MDSPAN_TRAIT(std::is_default_constructible, accessor_type) + MDSPAN_IMPL_TRAIT(std::is_constructible, mapping_type, extents_type) && + MDSPAN_IMPL_TRAIT(std::is_default_constructible, accessor_type) ) ) MDSPAN_INLINE_FUNCTION explicit constexpr mdspan(data_handle_type p, SizeTypes... dynamic_extents) // TODO @proposal-bug shouldn't I be allowed to do `move(p)` here? - : __members(std::move(p), __map_acc_pair_t(mapping_type(extents_type(static_cast(std::move(dynamic_extents))...)), accessor_type())) + : m_members(std::move(p), map_acc_pair_t(mapping_type(extents_type(static_cast(std::move(dynamic_extents))...)), accessor_type())) { } MDSPAN_TEMPLATE_REQUIRES( class SizeType, size_t N, /* requires */ ( - _MDSPAN_TRAIT(std::is_convertible, const SizeType&, index_type) && - _MDSPAN_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&) && + MDSPAN_IMPL_TRAIT(std::is_convertible, const SizeType&, index_type) && + MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&) && ((N == rank()) || (N == rank_dynamic())) && - _MDSPAN_TRAIT(std::is_constructible, mapping_type, extents_type) && - _MDSPAN_TRAIT(std::is_default_constructible, accessor_type) + MDSPAN_IMPL_TRAIT(std::is_constructible, mapping_type, extents_type) && + MDSPAN_IMPL_TRAIT(std::is_default_constructible, accessor_type) ) ) MDSPAN_CONDITIONAL_EXPLICIT(N != rank_dynamic()) MDSPAN_INLINE_FUNCTION constexpr mdspan(data_handle_type p, const std::array& dynamic_extents) - : __members(std::move(p), __map_acc_pair_t(mapping_type(extents_type(dynamic_extents)), accessor_type())) + : m_members(std::move(p), map_acc_pair_t(mapping_type(extents_type(dynamic_extents)), accessor_type())) { } #ifdef __cpp_lib_span MDSPAN_TEMPLATE_REQUIRES( class SizeType, size_t N, /* requires */ ( - _MDSPAN_TRAIT(std::is_convertible, const SizeType&, index_type) && - _MDSPAN_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&) && + MDSPAN_IMPL_TRAIT(std::is_convertible, const SizeType&, index_type) && + MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&) && ((N == rank()) || (N == rank_dynamic())) && - _MDSPAN_TRAIT(std::is_constructible, mapping_type, extents_type) && - _MDSPAN_TRAIT(std::is_default_constructible, accessor_type) + MDSPAN_IMPL_TRAIT(std::is_constructible, mapping_type, extents_type) && + MDSPAN_IMPL_TRAIT(std::is_default_constructible, accessor_type) ) ) MDSPAN_CONDITIONAL_EXPLICIT(N != rank_dynamic()) MDSPAN_INLINE_FUNCTION constexpr mdspan(data_handle_type p, std::span dynamic_extents) - : __members(std::move(p), __map_acc_pair_t(mapping_type(extents_type(as_const(dynamic_extents))), accessor_type())) + : m_members(std::move(p), map_acc_pair_t(mapping_type(extents_type(as_const(dynamic_extents))), accessor_type())) { } #endif MDSPAN_FUNCTION_REQUIRES( (MDSPAN_INLINE_FUNCTION constexpr), mdspan, (data_handle_type p, const extents_type& exts), , - /* requires */ (_MDSPAN_TRAIT(std::is_default_constructible, accessor_type) && - _MDSPAN_TRAIT(std::is_constructible, mapping_type, const extents_type&)) - ) : __members(std::move(p), __map_acc_pair_t(mapping_type(exts), accessor_type())) + /* requires */ (MDSPAN_IMPL_TRAIT(std::is_default_constructible, accessor_type) && + MDSPAN_IMPL_TRAIT(std::is_constructible, mapping_type, const extents_type&)) + ) : m_members(std::move(p), map_acc_pair_t(mapping_type(exts), accessor_type())) { } MDSPAN_FUNCTION_REQUIRES( (MDSPAN_INLINE_FUNCTION constexpr), mdspan, (data_handle_type p, const mapping_type& m), , - /* requires */ (_MDSPAN_TRAIT(std::is_default_constructible, accessor_type)) - ) : __members(std::move(p), __map_acc_pair_t(m, accessor_type())) + /* requires */ (MDSPAN_IMPL_TRAIT(std::is_default_constructible, accessor_type)) + ) : m_members(std::move(p), map_acc_pair_t(m, accessor_type())) { } MDSPAN_INLINE_FUNCTION constexpr mdspan(data_handle_type p, const mapping_type& m, const accessor_type& a) - : __members(std::move(p), __map_acc_pair_t(m, a)) + : m_members(std::move(p), map_acc_pair_t(m, a)) { } MDSPAN_TEMPLATE_REQUIRES( class OtherElementType, class OtherExtents, class OtherLayoutPolicy, class OtherAccessor, /* requires */ ( - _MDSPAN_TRAIT(std::is_constructible, mapping_type, const typename OtherLayoutPolicy::template mapping&) && - _MDSPAN_TRAIT(std::is_constructible, accessor_type, const OtherAccessor&) + MDSPAN_IMPL_TRAIT(std::is_constructible, mapping_type, const typename OtherLayoutPolicy::template mapping&) && + MDSPAN_IMPL_TRAIT(std::is_constructible, accessor_type, const OtherAccessor&) ) ) MDSPAN_CONDITIONAL_EXPLICIT( - !_MDSPAN_TRAIT(std::is_convertible, const typename OtherLayoutPolicy::template mapping&, mapping_type) || - !_MDSPAN_TRAIT(std::is_convertible, const OtherAccessor&, accessor_type) + !MDSPAN_IMPL_TRAIT(std::is_convertible, const typename OtherLayoutPolicy::template mapping&, mapping_type) || + !MDSPAN_IMPL_TRAIT(std::is_convertible, const OtherAccessor&, accessor_type) ) MDSPAN_INLINE_FUNCTION constexpr mdspan(const mdspan& other) - : __members(other.__ptr_ref(), __map_acc_pair_t(other.__mapping_ref(), other.__accessor_ref())) + : m_members(other.ptr_ref(), map_acc_pair_t(other.mapping_ref(), other.accessor_ref())) { - static_assert(_MDSPAN_TRAIT(std::is_constructible, data_handle_type, typename OtherAccessor::data_handle_type),"Incompatible data_handle_type for mdspan construction"); - static_assert(_MDSPAN_TRAIT(std::is_constructible, extents_type, OtherExtents),"Incompatible extents for mdspan construction"); + static_assert(MDSPAN_IMPL_TRAIT(std::is_constructible, data_handle_type, typename OtherAccessor::data_handle_type),"Incompatible data_handle_type for mdspan construction"); + static_assert(MDSPAN_IMPL_TRAIT(std::is_constructible, extents_type, OtherExtents),"Incompatible extents for mdspan construction"); /* * TODO: Check precondition * For each rank index r of extents_type, static_extent(r) == dynamic_extent || static_extent(r) == other.extent(r) is true. @@ -212,54 +217,114 @@ public: ~mdspan() = default; */ - MDSPAN_INLINE_FUNCTION_DEFAULTED _MDSPAN_CONSTEXPR_14_DEFAULTED mdspan& operator=(const mdspan&) = default; - MDSPAN_INLINE_FUNCTION_DEFAULTED _MDSPAN_CONSTEXPR_14_DEFAULTED mdspan& operator=(mdspan&&) = default; + MDSPAN_INLINE_FUNCTION_DEFAULTED MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED mdspan& operator=(const mdspan&) = default; + MDSPAN_INLINE_FUNCTION_DEFAULTED MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED mdspan& operator=(mdspan&&) = default; //-------------------------------------------------------------------------------- // [mdspan.basic.mapping], mdspan mapping domain multidimensional index to access codomain element + MDSPAN_TEMPLATE_REQUIRES( + class... SizeTypes, + /* requires */ ( + extents_type::rank() == sizeof...(SizeTypes) && + (detail::are_valid_indices()) + ) + ) + constexpr reference at(SizeTypes... indices) const + { + size_t r = 0; + for (const auto& index : {indices...}) { + if (is_index_oor(index, mapping_ref().extents().extent(r))) { + throw std::out_of_range( + "mdspan::at(...," + std::to_string(index) + ",...) out-of-range at rank index " + std::to_string(r) + + " for mdspan with extent {...," + std::to_string(mapping_ref().extents().extent(r)) + ",...}"); + } + ++r; + } + return accessor_ref().access(ptr_ref(), mapping_ref()(static_cast(std::move(indices))...)); + } + + MDSPAN_TEMPLATE_REQUIRES( + class SizeType, + /* requires */ ( + MDSPAN_IMPL_TRAIT(std::is_convertible, const SizeType&, index_type) && + MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&) + ) + ) + constexpr reference at(const std::array& indices) const + { + for (size_t r = 0; r < indices.size(); ++r) { + if (is_index_oor(indices[r], mapping_ref().extents().extent(r))) { + throw std::out_of_range( + "mdspan::at({...," + std::to_string(indices[r]) + ",...}) out-of-range at rank index " + std::to_string(r) + + " for mdspan with extent {...," + std::to_string(mapping_ref().extents().extent(r)) + ",...}"); + } + } + return deduction_workaround_impl::template callop(*this, indices); + } + + #ifdef __cpp_lib_span + MDSPAN_TEMPLATE_REQUIRES( + class SizeType, + /* requires */ ( + MDSPAN_IMPL_TRAIT(std::is_convertible, const SizeType&, index_type) && + MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&) + ) + ) + constexpr reference at(std::span indices) const + { + for (size_t r = 0; r < indices.size(); ++r) { + if (is_index_oor(indices[r], mapping_ref().extents().extent(r))) { + throw std::out_of_range( + "mdspan::at({...," + std::to_string(indices[r]) + ",...}) out-of-range at rank index " + std::to_string(r) + + " for mdspan with extent {...," + std::to_string(mapping_ref().extents().extent(r)) + ",...}"); + } + } + return deduction_workaround_impl::template callop(*this, indices); + } + #endif // __cpp_lib_span + #if MDSPAN_USE_BRACKET_OPERATOR MDSPAN_TEMPLATE_REQUIRES( class... SizeTypes, /* requires */ ( - _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(std::is_convertible, SizeTypes, index_type) /* && ... */) && - _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(std::is_nothrow_constructible, index_type, SizeTypes) /* && ... */) && - (rank() == sizeof...(SizeTypes)) + extents_type::rank() == sizeof...(SizeTypes) && + (detail::are_valid_indices()) ) ) MDSPAN_FORCE_INLINE_FUNCTION constexpr reference operator[](SizeTypes... indices) const { - return __accessor_ref().access(__ptr_ref(), __mapping_ref()(static_cast(std::move(indices))...)); + return accessor_ref().access(ptr_ref(), mapping_ref()(static_cast(std::move(indices))...)); } #endif MDSPAN_TEMPLATE_REQUIRES( class SizeType, /* requires */ ( - _MDSPAN_TRAIT(std::is_convertible, const SizeType&, index_type) && - _MDSPAN_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&) + MDSPAN_IMPL_TRAIT(std::is_convertible, const SizeType&, index_type) && + MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&) ) ) MDSPAN_FORCE_INLINE_FUNCTION - constexpr reference operator[](const std::array< SizeType, rank()>& indices) const + constexpr reference operator[](const std::array& indices) const { - return __impl::template __callop(*this, indices); + return deduction_workaround_impl::template callop(*this, indices); } #ifdef __cpp_lib_span MDSPAN_TEMPLATE_REQUIRES( class SizeType, /* requires */ ( - _MDSPAN_TRAIT(std::is_convertible, const SizeType&, index_type) && - _MDSPAN_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&) + MDSPAN_IMPL_TRAIT(std::is_convertible, const SizeType&, index_type) && + MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&) ) ) MDSPAN_FORCE_INLINE_FUNCTION constexpr reference operator[](std::span indices) const { - return __impl::template __callop(*this, indices); + return deduction_workaround_impl::template callop(*this, indices); } #endif // __cpp_lib_span @@ -267,15 +332,15 @@ public: MDSPAN_TEMPLATE_REQUIRES( class Index, /* requires */ ( - _MDSPAN_TRAIT(std::is_convertible, Index, index_type) && - _MDSPAN_TRAIT(std::is_nothrow_constructible, index_type, Index) && + MDSPAN_IMPL_TRAIT(std::is_convertible, Index, index_type) && + MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, index_type, Index) && extents_type::rank() == 1 ) ) MDSPAN_FORCE_INLINE_FUNCTION constexpr reference operator[](Index idx) const { - return __accessor_ref().access(__ptr_ref(), __mapping_ref()(static_cast(std::move(idx)))); + return accessor_ref().access(ptr_ref(), mapping_ref()(static_cast(std::move(idx)))); } #endif @@ -290,54 +355,54 @@ public: MDSPAN_FORCE_INLINE_FUNCTION constexpr reference operator()(SizeTypes... indices) const { - return __accessor_ref().access(__ptr_ref(), __mapping_ref()(static_cast(std::move(indices))...)); + return accessor_ref().access(ptr_ref(), mapping_ref()(static_cast(std::move(indices))...)); } MDSPAN_TEMPLATE_REQUIRES( class SizeType, /* requires */ ( - _MDSPAN_TRAIT(std::is_convertible, const SizeType&, index_type) && - _MDSPAN_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&) + MDSPAN_IMPL_TRAIT(std::is_convertible, const SizeType&, index_type) && + MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&) ) ) MDSPAN_FORCE_INLINE_FUNCTION constexpr reference operator()(const std::array& indices) const { - return __impl::template __callop(*this, indices); + return deduction_workaround_impl::template callop(*this, indices); } #ifdef __cpp_lib_span MDSPAN_TEMPLATE_REQUIRES( class SizeType, /* requires */ ( - _MDSPAN_TRAIT(std::is_convertible, const SizeType&, index_type) && - _MDSPAN_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&) + MDSPAN_IMPL_TRAIT(std::is_convertible, const SizeType&, index_type) && + MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&) ) ) MDSPAN_FORCE_INLINE_FUNCTION constexpr reference operator()(std::span indices) const { - return __impl::template __callop(*this, indices); + return deduction_workaround_impl::template callop(*this, indices); } #endif // __cpp_lib_span #endif // MDSPAN_USE_PAREN_OPERATOR MDSPAN_INLINE_FUNCTION constexpr size_type size() const noexcept { - return static_cast(__impl::__size(*this)); - }; + return static_cast(deduction_workaround_impl::size(*this)); + } MDSPAN_INLINE_FUNCTION constexpr bool empty() const noexcept { - return __impl::__empty(*this); - }; + return deduction_workaround_impl::empty(*this); + } MDSPAN_INLINE_FUNCTION friend constexpr void swap(mdspan& x, mdspan& y) noexcept { // can't call the std::swap inside on HIP - #if !defined(_MDSPAN_HAS_HIP) && !defined(_MDSPAN_HAS_CUDA) + #if !defined(MDSPAN_IMPL_HAS_HIP) && !defined(MDSPAN_IMPL_HAS_CUDA) using std::swap; - swap(x.__ptr_ref(), y.__ptr_ref()); - swap(x.__mapping_ref(), y.__mapping_ref()); - swap(x.__accessor_ref(), y.__accessor_ref()); + swap(x.ptr_ref(), y.ptr_ref()); + swap(x.mapping_ref(), y.mapping_ref()); + swap(x.accessor_ref(), y.accessor_ref()); #else mdspan tmp = y; y = x; @@ -349,43 +414,60 @@ public: // [mdspan.basic.domobs], mdspan observers of the domain multidimensional index space - MDSPAN_INLINE_FUNCTION constexpr const extents_type& extents() const noexcept { return __mapping_ref().extents(); }; - MDSPAN_INLINE_FUNCTION constexpr const data_handle_type& data_handle() const noexcept { return __ptr_ref(); }; - MDSPAN_INLINE_FUNCTION constexpr const mapping_type& mapping() const noexcept { return __mapping_ref(); }; - MDSPAN_INLINE_FUNCTION constexpr const accessor_type& accessor() const noexcept { return __accessor_ref(); }; + MDSPAN_INLINE_FUNCTION constexpr const extents_type& extents() const noexcept { return mapping_ref().extents(); } + MDSPAN_INLINE_FUNCTION constexpr const data_handle_type& data_handle() const noexcept { return ptr_ref(); } + MDSPAN_INLINE_FUNCTION constexpr const mapping_type& mapping() const noexcept { return mapping_ref(); } + MDSPAN_INLINE_FUNCTION constexpr const accessor_type& accessor() const noexcept { return accessor_ref(); } //-------------------------------------------------------------------------------- // [mdspan.basic.obs], mdspan observers of the mapping - MDSPAN_INLINE_FUNCTION static constexpr bool is_always_unique() { return mapping_type::is_always_unique(); }; - MDSPAN_INLINE_FUNCTION static constexpr bool is_always_exhaustive() { return mapping_type::is_always_exhaustive(); }; - MDSPAN_INLINE_FUNCTION static constexpr bool is_always_strided() { return mapping_type::is_always_strided(); }; + MDSPAN_INLINE_FUNCTION static constexpr bool is_always_unique() { return mapping_type::is_always_unique(); } + MDSPAN_INLINE_FUNCTION static constexpr bool is_always_exhaustive() { return mapping_type::is_always_exhaustive(); } + MDSPAN_INLINE_FUNCTION static constexpr bool is_always_strided() { return mapping_type::is_always_strided(); } - MDSPAN_INLINE_FUNCTION constexpr bool is_unique() const { return __mapping_ref().is_unique(); }; - MDSPAN_INLINE_FUNCTION constexpr bool is_exhaustive() const { return __mapping_ref().is_exhaustive(); }; - MDSPAN_INLINE_FUNCTION constexpr bool is_strided() const { return __mapping_ref().is_strided(); }; - MDSPAN_INLINE_FUNCTION constexpr index_type stride(size_t r) const { return __mapping_ref().stride(r); }; + MDSPAN_INLINE_FUNCTION constexpr bool is_unique() const { return mapping_ref().is_unique(); } + MDSPAN_INLINE_FUNCTION constexpr bool is_exhaustive() const { return mapping_ref().is_exhaustive(); } + MDSPAN_INLINE_FUNCTION constexpr bool is_strided() const { return mapping_ref().is_strided(); } + MDSPAN_INLINE_FUNCTION constexpr index_type stride(size_t r) const { return mapping_ref().stride(r); } private: - detail::__compressed_pair __members{}; + detail::impl_compressed_pair m_members{}; - MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 data_handle_type& __ptr_ref() noexcept { return __members.__first(); } - MDSPAN_FORCE_INLINE_FUNCTION constexpr data_handle_type const& __ptr_ref() const noexcept { return __members.__first(); } - MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 mapping_type& __mapping_ref() noexcept { return __members.__second().__first(); } - MDSPAN_FORCE_INLINE_FUNCTION constexpr mapping_type const& __mapping_ref() const noexcept { return __members.__second().__first(); } - MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 accessor_type& __accessor_ref() noexcept { return __members.__second().__second(); } - MDSPAN_FORCE_INLINE_FUNCTION constexpr accessor_type const& __accessor_ref() const noexcept { return __members.__second().__second(); } + MDSPAN_FORCE_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 data_handle_type& ptr_ref() noexcept { return m_members.first(); } + MDSPAN_FORCE_INLINE_FUNCTION constexpr data_handle_type const& ptr_ref() const noexcept { return m_members.first(); } + MDSPAN_FORCE_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 mapping_type& mapping_ref() noexcept { return m_members.second().first(); } + MDSPAN_FORCE_INLINE_FUNCTION constexpr mapping_type const& mapping_ref() const noexcept { return m_members.second().first(); } + MDSPAN_FORCE_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 accessor_type& accessor_ref() noexcept { return m_members.second().second(); } + MDSPAN_FORCE_INLINE_FUNCTION constexpr accessor_type const& accessor_ref() const noexcept { return m_members.second().second(); } + + MDSPAN_TEMPLATE_REQUIRES( + class SizeType, + /* requires */ ( + MDSPAN_IMPL_TRAIT(std::is_convertible, const SizeType&, index_type) && + MDSPAN_IMPL_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&) + ) + ) + MDSPAN_FORCE_INLINE_FUNCTION constexpr bool is_index_oor(SizeType index, index_type extent) const noexcept { + // Check for negative indices + if MDSPAN_IMPL_IF_CONSTEXPR_17 (MDSPAN_IMPL_TRAIT(std::is_signed, SizeType)) { + if(index < 0) { + return true; + } + } + return static_cast(index) >= extent; + } template friend class mdspan; }; -#if defined(_MDSPAN_USE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION) +#if defined(MDSPAN_IMPL_USE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION) MDSPAN_TEMPLATE_REQUIRES( class ElementType, class... SizeTypes, - /* requires */ _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(std::is_convertible, SizeTypes, size_t) /* && ... */) && + /* requires */ MDSPAN_IMPL_FOLD_AND(MDSPAN_IMPL_TRAIT(std::is_convertible, SizeTypes, size_t) /* && ... */) && (sizeof...(SizeTypes) > 0) ) MDSPAN_DEDUCTION_GUIDE explicit mdspan(ElementType*, SizeTypes...) @@ -393,13 +475,13 @@ MDSPAN_DEDUCTION_GUIDE explicit mdspan(ElementType*, SizeTypes...) MDSPAN_TEMPLATE_REQUIRES( class Pointer, - (_MDSPAN_TRAIT(std::is_pointer, std::remove_reference_t)) + (MDSPAN_IMPL_TRAIT(std::is_pointer, std::remove_reference_t)) ) MDSPAN_DEDUCTION_GUIDE mdspan(Pointer&&) -> mdspan>, extents>; MDSPAN_TEMPLATE_REQUIRES( class CArray, - (_MDSPAN_TRAIT(std::is_array, CArray) && (std::rank_v == 1)) + (MDSPAN_IMPL_TRAIT(std::is_array, CArray) && (std::rank_v == 1)) ) MDSPAN_DEDUCTION_GUIDE mdspan(CArray&) -> mdspan, extents>>; diff --git a/ext/mdspan/include/experimental/__p0009_bits/no_unique_address.hpp b/ext/mdspan/include/experimental/__p0009_bits/no_unique_address.hpp index 36e64ee..b7b07c6 100644 --- a/ext/mdspan/include/experimental/__p0009_bits/no_unique_address.hpp +++ b/ext/mdspan/include/experimental/__p0009_bits/no_unique_address.hpp @@ -23,72 +23,72 @@ namespace detail { //============================================================================== -template -struct __no_unique_address_emulation { - using __stored_type = _T; - _T __v; - MDSPAN_FORCE_INLINE_FUNCTION constexpr _T const &__ref() const noexcept { - return __v; +template +struct no_unique_address_emulation { + using stored_type = T; + T m_v; + MDSPAN_FORCE_INLINE_FUNCTION constexpr T const &ref() const noexcept { + return m_v; } - MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T &__ref() noexcept { - return __v; + MDSPAN_FORCE_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 T &ref() noexcept { + return m_v; } }; // Empty case -// This doesn't work if _T is final, of course, but we're not using anything +// This doesn't work if T is final, of course, but we're not using anything // like that currently. That kind of thing could be added pretty easily though -template -struct __no_unique_address_emulation< - _T, _Disambiguator, - std::enable_if_t<_MDSPAN_TRAIT(std::is_empty, _T) && +template +struct no_unique_address_emulation< + T, Disambiguator, + std::enable_if_t> : -#ifdef _MDSPAN_COMPILER_MSVC + MDSPAN_IMPL_TRAIT(std::is_trivially_destructible, T)>> : +#ifdef MDSPAN_IMPL_COMPILER_MSVC // MSVC doesn't allow you to access public static member functions of a type // when you *happen* to privately inherit from that type. protected #else // But we still want this to be private if possible so that we don't accidentally - // access members of _T directly rather than calling __ref() first, which wouldn't - // work if _T happens to be stateful and thus we're using the unspecialized definition - // of __no_unique_address_emulation above. + // access members of T directly rather than calling ref() first, which wouldn't + // work if T happens to be stateful and thus we're using the unspecialized definition + // of no_unique_address_emulation above. private #endif - _T { - using __stored_type = _T; - MDSPAN_FORCE_INLINE_FUNCTION constexpr _T const &__ref() const noexcept { - return *static_cast<_T const *>(this); + T { + using stored_type = T; + MDSPAN_FORCE_INLINE_FUNCTION constexpr T const &ref() const noexcept { + return *static_cast(this); } - MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T &__ref() noexcept { - return *static_cast<_T *>(this); + MDSPAN_FORCE_INLINE_FUNCTION MDSPAN_IMPL_CONSTEXPR_14 T &ref() noexcept { + return *static_cast(this); } MDSPAN_INLINE_FUNCTION_DEFAULTED - constexpr __no_unique_address_emulation() noexcept = default; + constexpr no_unique_address_emulation() noexcept = default; MDSPAN_INLINE_FUNCTION_DEFAULTED - constexpr __no_unique_address_emulation( - __no_unique_address_emulation const &) noexcept = default; + constexpr no_unique_address_emulation( + no_unique_address_emulation const &) noexcept = default; MDSPAN_INLINE_FUNCTION_DEFAULTED - constexpr __no_unique_address_emulation( - __no_unique_address_emulation &&) noexcept = default; + constexpr no_unique_address_emulation( + no_unique_address_emulation &&) noexcept = default; MDSPAN_INLINE_FUNCTION_DEFAULTED - _MDSPAN_CONSTEXPR_14_DEFAULTED __no_unique_address_emulation & - operator=(__no_unique_address_emulation const &) noexcept = default; + MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED no_unique_address_emulation & + operator=(no_unique_address_emulation const &) noexcept = default; MDSPAN_INLINE_FUNCTION_DEFAULTED - _MDSPAN_CONSTEXPR_14_DEFAULTED __no_unique_address_emulation & - operator=(__no_unique_address_emulation &&) noexcept = default; + MDSPAN_IMPL_CONSTEXPR_14_DEFAULTED no_unique_address_emulation & + operator=(no_unique_address_emulation &&) noexcept = default; MDSPAN_INLINE_FUNCTION_DEFAULTED - ~__no_unique_address_emulation() noexcept = default; + ~no_unique_address_emulation() noexcept = default; // Explicitly make this not a reference so that the copy or move // constructor still gets called. MDSPAN_INLINE_FUNCTION - explicit constexpr __no_unique_address_emulation(_T const& __v) noexcept : _T(__v) {} + explicit constexpr no_unique_address_emulation(T const& v) noexcept : T(v) {} MDSPAN_INLINE_FUNCTION - explicit constexpr __no_unique_address_emulation(_T&& __v) noexcept : _T(::std::move(__v)) {} + explicit constexpr no_unique_address_emulation(T&& v) noexcept : T(::std::move(v)) {} }; //============================================================================== diff --git a/ext/mdspan/include/experimental/__p0009_bits/trait_backports.hpp b/ext/mdspan/include/experimental/__p0009_bits/trait_backports.hpp index 4933dd9..70651a7 100644 --- a/ext/mdspan/include/experimental/__p0009_bits/trait_backports.hpp +++ b/ext/mdspan/include/experimental/__p0009_bits/trait_backports.hpp @@ -25,30 +25,30 @@ //============================================================================== // {{{1 -#ifdef _MDSPAN_NEEDS_TRAIT_VARIABLE_TEMPLATE_BACKPORTS +#ifdef MDSPAN_IMPL_NEEDS_TRAIT_VARIABLE_TEMPLATE_BACKPORTS -#if _MDSPAN_USE_VARIABLE_TEMPLATES +#if MDSPAN_IMPL_USE_VARIABLE_TEMPLATES namespace MDSPAN_IMPL_STANDARD_NAMESPACE { -#define _MDSPAN_BACKPORT_TRAIT(TRAIT) \ - template _MDSPAN_INLINE_VARIABLE constexpr auto TRAIT##_v = TRAIT::value; +#define MDSPAN_IMPL_BACKPORT_TRAIT(TRAIT) \ + template MDSPAN_IMPL_INLINE_VARIABLE constexpr auto TRAIT##_v = TRAIT::value; -_MDSPAN_BACKPORT_TRAIT(is_assignable) -_MDSPAN_BACKPORT_TRAIT(is_constructible) -_MDSPAN_BACKPORT_TRAIT(is_convertible) -_MDSPAN_BACKPORT_TRAIT(is_default_constructible) -_MDSPAN_BACKPORT_TRAIT(is_trivially_destructible) -_MDSPAN_BACKPORT_TRAIT(is_same) -_MDSPAN_BACKPORT_TRAIT(is_empty) -_MDSPAN_BACKPORT_TRAIT(is_void) +MDSPAN_IMPL_BACKPORT_TRAIT(is_assignable) +MDSPAN_IMPL_BACKPORT_TRAIT(is_constructible) +MDSPAN_IMPL_BACKPORT_TRAIT(is_convertible) +MDSPAN_IMPL_BACKPORT_TRAIT(is_default_constructible) +MDSPAN_IMPL_BACKPORT_TRAIT(is_trivially_destructible) +MDSPAN_IMPL_BACKPORT_TRAIT(is_same) +MDSPAN_IMPL_BACKPORT_TRAIT(is_empty) +MDSPAN_IMPL_BACKPORT_TRAIT(is_void) -#undef _MDSPAN_BACKPORT_TRAIT +#undef MDSPAN_IMPL_BACKPORT_TRAIT } // end namespace MDSPAN_IMPL_STANDARD_NAMESPACE -#endif // _MDSPAN_USE_VARIABLE_TEMPLATES +#endif // MDSPAN_IMPL_USE_VARIABLE_TEMPLATES -#endif // _MDSPAN_NEEDS_TRAIT_VARIABLE_TEMPLATE_BACKPORTS +#endif // MDSPAN_IMPL_NEEDS_TRAIT_VARIABLE_TEMPLATE_BACKPORTS // end Variable template trait backports (e.g., is_void_v) }}}1 //============================================================================== @@ -56,7 +56,7 @@ _MDSPAN_BACKPORT_TRAIT(is_void) //============================================================================== // {{{1 -#if !defined(_MDSPAN_USE_INTEGER_SEQUENCE) || !_MDSPAN_USE_INTEGER_SEQUENCE +#if !defined(MDSPAN_IMPL_USE_INTEGER_SEQUENCE_14) || !MDSPAN_IMPL_USE_INTEGER_SEQUENCE_14 namespace MDSPAN_IMPL_STANDARD_NAMESPACE { @@ -107,20 +107,20 @@ using index_sequence_for = make_index_sequence; //============================================================================== // {{{1 -#if !defined(_MDSPAN_USE_STANDARD_TRAIT_ALIASES) || !_MDSPAN_USE_STANDARD_TRAIT_ALIASES +#if !defined(MDSPAN_IMPL_USE_STANDARD_TRAIT_ALIASES) || !MDSPAN_IMPL_USE_STANDARD_TRAIT_ALIASES namespace MDSPAN_IMPL_STANDARD_NAMESPACE { -#define _MDSPAN_BACKPORT_TRAIT_ALIAS(TRAIT) \ +#define MDSPAN_IMPL_BACKPORT_TRAIT_ALIAS(TRAIT) \ template using TRAIT##_t = typename TRAIT::type; -_MDSPAN_BACKPORT_TRAIT_ALIAS(remove_cv) -_MDSPAN_BACKPORT_TRAIT_ALIAS(remove_reference) +MDSPAN_IMPL_BACKPORT_TRAIT_ALIAS(remove_cv) +MDSPAN_IMPL_BACKPORT_TRAIT_ALIAS(remove_reference) -template -using enable_if_t = typename enable_if<_B, _T>::type; +template +using enable_if_t = typename enable_if<_B, T>::type; -#undef _MDSPAN_BACKPORT_TRAIT_ALIAS +#undef MDSPAN_IMPL_BACKPORT_TRAIT_ALIAS } // end namespace MDSPAN_IMPL_STANDARD_NAMESPACE diff --git a/ext/mdspan/include/experimental/__p0009_bits/type_list.hpp b/ext/mdspan/include/experimental/__p0009_bits/type_list.hpp index deca7c1..23d5856 100644 --- a/ext/mdspan/include/experimental/__p0009_bits/type_list.hpp +++ b/ext/mdspan/include/experimental/__p0009_bits/type_list.hpp @@ -23,59 +23,59 @@ namespace MDSPAN_IMPL_STANDARD_NAMESPACE { namespace detail { -template struct __type_list { static constexpr auto __size = sizeof...(_Ts); }; +template struct type_list { static constexpr auto size = sizeof...(Ts); }; // Implementation of type_list at() that's heavily optimized for small typelists -template struct __type_at; -template > struct __type_at_large_impl; +template struct type_at; +template > struct type_at_large_impl; -template -struct __type_at_entry { }; +template +struct type_at_entry { }; -template -struct __type_at_assign_op_ignore_rest { - template - __type_at_assign_op_ignore_rest<_Result> operator=(_T&&); - using type = _Result; +template +struct type_at_assign_op_ignore_rest { + template + type_at_assign_op_ignore_rest operator=(T&&); + using type = Result; }; -struct __type_at_assign_op_impl { - template - __type_at_assign_op_impl operator=(__type_at_entry<_I, _Idx, _T>&&); - template - __type_at_assign_op_ignore_rest<_T> operator=(__type_at_entry<_I, _I, _T>&&); +struct type_at_assign_op_impl { + template + type_at_assign_op_impl operator=(type_at_entry&&); + template + type_at_assign_op_ignore_rest operator=(type_at_entry&&); }; -template -struct __type_at_large_impl<_I, __type_list<_Ts...>, std::integer_sequence> +template +struct type_at_large_impl, std::integer_sequence> : decltype( - _MDSPAN_FOLD_ASSIGN_LEFT(__type_at_assign_op_impl{}, /* = ... = */ __type_at_entry<_I, _Idxs, _Ts>{}) + MDSPAN_IMPL_FOLD_ASSIGN_LEFT(type_at_assign_op_impl{}, /* = ... = */ type_at_entry{}) ) { }; -template -struct __type_at<_I, __type_list<_Ts...>> - : __type_at_large_impl<_I, __type_list<_Ts...>> +template +struct type_at> + : type_at_large_impl> { }; -template -struct __type_at<0, __type_list<_T0, _Ts...>> { - using type = _T0; +template +struct type_at<0, type_list> { + using type = T0; }; -template -struct __type_at<1, __type_list<_T0, _T1, _Ts...>> { - using type = _T1; +template +struct type_at<1, type_list> { + using type = T1; }; -template -struct __type_at<2, __type_list<_T0, _T1, _T2, _Ts...>> { - using type = _T2; +template +struct type_at<2, type_list> { + using type = T2; }; -template -struct __type_at<3, __type_list<_T0, _T1, _T2, _T3, _Ts...>> { - using type = _T3; +template +struct type_at<3, type_list> { + using type = T3; }; @@ -84,4 +84,3 @@ struct __type_at<3, __type_list<_T0, _T1, _T2, _T3, _Ts...>> { //============================================================================== } // end namespace MDSPAN_IMPL_STANDARD_NAMESPACE - diff --git a/ext/mdspan/include/experimental/__p0009_bits/utility.hpp b/ext/mdspan/include/experimental/__p0009_bits/utility.hpp index a078eeb..2d8a938 100644 --- a/ext/mdspan/include/experimental/__p0009_bits/utility.hpp +++ b/ext/mdspan/include/experimental/__p0009_bits/utility.hpp @@ -4,6 +4,12 @@ #include #include #include +#if defined(MDSPAN_IMPL_HAS_CUDA) && defined(__NVCC__) && (__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__ * 10 >= 1260) +#include +#else +#include +#endif +#include "macros.hpp" namespace MDSPAN_IMPL_STANDARD_NAMESPACE { namespace detail { @@ -46,7 +52,10 @@ constexpr bool rankwise_equal(with_rank, const T1& x, const T2& y, F func) return match; } -constexpr struct +#if MDSPAN_HAS_CXX_17 +inline +#endif +constexpr struct extent_functor { template MDSPAN_INLINE_FUNCTION @@ -56,7 +65,10 @@ constexpr struct } } extent; -constexpr struct +#if MDSPAN_HAS_CXX_17 +inline +#endif +constexpr struct stride_functor { template MDSPAN_INLINE_FUNCTION @@ -81,7 +93,7 @@ struct integral_constant { // These interop functions work, because other than the value_type operator // everything of std::integral_constant works on device (defaulted functions) MDSPAN_FUNCTION - constexpr integral_constant(std::integral_constant) {}; + constexpr integral_constant(std::integral_constant) {} MDSPAN_FUNCTION constexpr operator std::integral_constant() const noexcept { return std::integral_constant{}; @@ -164,8 +176,70 @@ constexpr const auto& get(const tuple& vals) { return vals.template get template tuple(Elements ...) -> tuple; #endif + +#if MDSPAN_HAS_CXX_17 +// std::in_range and friends, tagged for device execution +// Backport from https://en.cppreference.com/w/cpp/utility/intcmp +// and https://en.cppreference.com/w/cpp/utility/in_range +template +MDSPAN_INLINE_FUNCTION constexpr bool cmp_less(T t, U u) noexcept { + if constexpr (std::is_signed_v == std::is_signed_v) + return t < u; + else if constexpr (std::is_signed_v) + return t < 0 || std::make_unsigned_t(t) < u; + else + return u >= 0 && t < std::make_unsigned_t(u); +} + +template +MDSPAN_INLINE_FUNCTION constexpr bool cmp_less_equal(T t, U u) noexcept { + return !cmp_less(u, t); +} + +template +MDSPAN_INLINE_FUNCTION constexpr bool cmp_greater_equal(T t, U u) noexcept { + return !cmp_less(t, u); +} + +template +MDSPAN_INLINE_FUNCTION constexpr bool in_range(T t) noexcept { +#if defined(MDSPAN_IMPL_HAS_CUDA) && defined(__NVCC__) && (__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__ * 10 >= 1260) + using cuda::std::numeric_limits; +#else + using std::numeric_limits; +#endif + return cmp_greater_equal(t, numeric_limits::min()) && + cmp_less_equal(t, numeric_limits::max()); +} + +template +MDSPAN_INLINE_FUNCTION constexpr bool +check_mul_result_is_nonnegative_and_representable(T a, T b) { +// FIXME_SYCL The code below compiles to old_llvm.umul.with.overflow.i64 +// which isn't defined in device code +#ifdef __SYCL_DEVICE_ONLY__ + return true; +#else + if (b == 0 || a == 0) + return true; + + if constexpr (std::is_signed_v) { + if ( a < 0 || b < 0 ) return false; + } +#if defined(MDSPAN_IMPL_HAS_CUDA) && defined(__NVCC__) && (__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__ * 10 >= 1260) + using cuda::std::numeric_limits; +#else + using std::numeric_limits; +#endif + return a <= numeric_limits::max() / b; +#endif +} +#endif } // namespace detail +#if MDSPAN_HAS_CXX_17 +inline +#endif constexpr struct mdspan_non_standard_tag { } mdspan_non_standard; diff --git a/ext/mdspan/include/experimental/__p1684_bits/mdarray.hpp b/ext/mdspan/include/experimental/__p1684_bits/mdarray.hpp index bdc5925..6f643a3 100644 --- a/ext/mdspan/include/experimental/__p1684_bits/mdarray.hpp +++ b/ext/mdspan/include/experimental/__p1684_bits/mdarray.hpp @@ -16,7 +16,7 @@ #pragma once -#include "../mdspan" +#include "../../mdspan/mdspan.hpp" #include #include @@ -59,7 +59,7 @@ template < > class mdarray { private: - static_assert(::MDSPAN_IMPL_STANDARD_NAMESPACE::detail::__is_extents_v, + static_assert(::MDSPAN_IMPL_STANDARD_NAMESPACE::detail::impl_is_extents_v, MDSPAN_IMPL_PROPOSED_NAMESPACE_STRING "::mdspan's Extents template parameter must be a specialization of " MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::extents."); public: @@ -104,9 +104,9 @@ public: class... SizeTypes, /* requires */ ( (::MDSPAN_IMPL_STANDARD_NAMESPACE::detail::are_valid_indices()) && - _MDSPAN_TRAIT( std::is_constructible, extents_type, SizeTypes...) && - _MDSPAN_TRAIT( std::is_constructible, mapping_type, extents_type) && - (_MDSPAN_TRAIT( std::is_constructible, container_type, size_t) || + MDSPAN_IMPL_TRAIT( std::is_constructible, extents_type, SizeTypes...) && + MDSPAN_IMPL_TRAIT( std::is_constructible, mapping_type, extents_type) && + (MDSPAN_IMPL_TRAIT( std::is_constructible, container_type, size_t) || container_is_array::value) && (extents_type::rank()>0 || extents_type::rank_dynamic()==0) ) @@ -119,16 +119,16 @@ public: MDSPAN_FUNCTION_REQUIRES( (MDSPAN_INLINE_FUNCTION constexpr), mdarray, (const extents_type& exts), , - /* requires */ ((_MDSPAN_TRAIT( std::is_constructible, container_type, size_t) || + /* requires */ ((MDSPAN_IMPL_TRAIT( std::is_constructible, container_type, size_t) || container_is_array::value) && - _MDSPAN_TRAIT( std::is_constructible, mapping_type, extents_type)) + MDSPAN_IMPL_TRAIT( std::is_constructible, mapping_type, extents_type)) ) : map_(exts), ctr_(container_is_array::construct(map_)) { } MDSPAN_FUNCTION_REQUIRES( (MDSPAN_INLINE_FUNCTION constexpr), mdarray, (const mapping_type& m), , - /* requires */ (_MDSPAN_TRAIT( std::is_constructible, container_type, size_t) || + /* requires */ (MDSPAN_IMPL_TRAIT( std::is_constructible, container_type, size_t) || container_is_array::value) ) : map_(m), ctr_(container_is_array::construct(map_)) { } @@ -136,7 +136,7 @@ public: MDSPAN_FUNCTION_REQUIRES( (MDSPAN_INLINE_FUNCTION constexpr), mdarray, (const extents_type& exts, const container_type& ctr), , - /* requires */ (_MDSPAN_TRAIT( std::is_constructible, mapping_type, extents_type)) + /* requires */ (MDSPAN_IMPL_TRAIT( std::is_constructible, mapping_type, extents_type)) ) : map_(exts), ctr_(ctr) { assert(ctr.size() >= static_cast(map_.required_span_size())); } @@ -147,7 +147,7 @@ public: MDSPAN_FUNCTION_REQUIRES( (MDSPAN_INLINE_FUNCTION constexpr), mdarray, (const extents_type& exts, container_type&& ctr), , - /* requires */ (_MDSPAN_TRAIT( std::is_constructible, mapping_type, extents_type)) + /* requires */ (MDSPAN_IMPL_TRAIT( std::is_constructible, mapping_type, extents_type)) ) : map_(exts), ctr_(std::move(ctr)) { assert(ctr_.size() >= static_cast(map_.required_span_size())); } @@ -159,8 +159,8 @@ public: MDSPAN_TEMPLATE_REQUIRES( class OtherElementType, class OtherExtents, class OtherLayoutPolicy, class OtherContainer, /* requires */ ( - _MDSPAN_TRAIT( std::is_constructible, mapping_type, typename OtherLayoutPolicy::template mapping) && - _MDSPAN_TRAIT( std::is_constructible, container_type, OtherContainer) + MDSPAN_IMPL_TRAIT( std::is_constructible, mapping_type, typename OtherLayoutPolicy::template mapping) && + MDSPAN_IMPL_TRAIT( std::is_constructible, container_type, OtherContainer) ) ) MDSPAN_INLINE_FUNCTION @@ -173,8 +173,8 @@ public: // Constructors for container types constructible from a size and allocator MDSPAN_TEMPLATE_REQUIRES( class Alloc, - /* requires */ (_MDSPAN_TRAIT( std::is_constructible, container_type, size_t, Alloc) && - _MDSPAN_TRAIT( std::is_constructible, mapping_type, extents_type)) + /* requires */ (MDSPAN_IMPL_TRAIT( std::is_constructible, container_type, size_t, Alloc) && + MDSPAN_IMPL_TRAIT( std::is_constructible, mapping_type, extents_type)) ) MDSPAN_INLINE_FUNCTION constexpr mdarray(const extents_type& exts, const Alloc& a) @@ -183,7 +183,7 @@ public: MDSPAN_TEMPLATE_REQUIRES( class Alloc, - /* requires */ (_MDSPAN_TRAIT( std::is_constructible, container_type, size_t, Alloc)) + /* requires */ (MDSPAN_IMPL_TRAIT( std::is_constructible, container_type, size_t, Alloc)) ) MDSPAN_INLINE_FUNCTION constexpr mdarray(const mapping_type& map, const Alloc& a) @@ -193,8 +193,8 @@ public: // Constructors for container types constructible from a container and allocator MDSPAN_TEMPLATE_REQUIRES( class Alloc, - /* requires */ (_MDSPAN_TRAIT( std::is_constructible, container_type, container_type, Alloc) && - _MDSPAN_TRAIT( std::is_constructible, mapping_type, extents_type)) + /* requires */ (MDSPAN_IMPL_TRAIT( std::is_constructible, container_type, container_type, Alloc) && + MDSPAN_IMPL_TRAIT( std::is_constructible, mapping_type, extents_type)) ) MDSPAN_INLINE_FUNCTION constexpr mdarray(const extents_type& exts, const container_type& ctr, const Alloc& a) @@ -203,7 +203,7 @@ public: MDSPAN_TEMPLATE_REQUIRES( class Alloc, - /* requires */ (_MDSPAN_TRAIT( std::is_constructible, container_type, size_t, Alloc)) + /* requires */ (MDSPAN_IMPL_TRAIT( std::is_constructible, container_type, size_t, Alloc)) ) MDSPAN_INLINE_FUNCTION constexpr mdarray(const mapping_type& map, const container_type& ctr, const Alloc& a) @@ -212,8 +212,8 @@ public: MDSPAN_TEMPLATE_REQUIRES( class Alloc, - /* requires */ (_MDSPAN_TRAIT( std::is_constructible, container_type, container_type, Alloc) && - _MDSPAN_TRAIT( std::is_constructible, mapping_type, extents_type)) + /* requires */ (MDSPAN_IMPL_TRAIT( std::is_constructible, container_type, container_type, Alloc) && + MDSPAN_IMPL_TRAIT( std::is_constructible, mapping_type, extents_type)) ) MDSPAN_INLINE_FUNCTION constexpr mdarray(const extents_type& exts, container_type&& ctr, const Alloc& a) @@ -222,7 +222,7 @@ public: MDSPAN_TEMPLATE_REQUIRES( class Alloc, - /* requires */ (_MDSPAN_TRAIT( std::is_constructible, container_type, size_t, Alloc)) + /* requires */ (MDSPAN_IMPL_TRAIT( std::is_constructible, container_type, size_t, Alloc)) ) MDSPAN_INLINE_FUNCTION constexpr mdarray(const mapping_type& map, container_type&& ctr, const Alloc& a) @@ -232,8 +232,8 @@ public: MDSPAN_TEMPLATE_REQUIRES( class OtherElementType, class OtherExtents, class OtherLayoutPolicy, class OtherContainer, class Alloc, /* requires */ ( - _MDSPAN_TRAIT( std::is_constructible, mapping_type, typename OtherLayoutPolicy::template mapping) && - _MDSPAN_TRAIT( std::is_constructible, container_type, OtherContainer, Alloc) + MDSPAN_IMPL_TRAIT( std::is_constructible, mapping_type, typename OtherLayoutPolicy::template mapping) && + MDSPAN_IMPL_TRAIT( std::is_constructible, container_type, OtherContainer, Alloc) ) ) MDSPAN_INLINE_FUNCTION @@ -255,7 +255,7 @@ public: MDSPAN_TEMPLATE_REQUIRES( class... SizeTypes, /* requires */ ( - _MDSPAN_FOLD_AND(_MDSPAN_TRAIT( std::is_convertible, SizeTypes, index_type) /* && ... */) && + MDSPAN_IMPL_FOLD_AND(MDSPAN_IMPL_TRAIT( std::is_convertible, SizeTypes, index_type) /* && ... */) && extents_type::rank() == sizeof...(SizeTypes) ) ) @@ -268,7 +268,7 @@ public: MDSPAN_TEMPLATE_REQUIRES( class... SizeTypes, /* requires */ ( - _MDSPAN_FOLD_AND(_MDSPAN_TRAIT( std::is_convertible, SizeTypes, index_type) /* && ... */) && + MDSPAN_IMPL_FOLD_AND(MDSPAN_IMPL_TRAIT( std::is_convertible, SizeTypes, index_type) /* && ... */) && extents_type::rank() == sizeof...(SizeTypes) ) ) @@ -283,27 +283,27 @@ public: MDSPAN_TEMPLATE_REQUIRES( class SizeType, size_t N, /* requires */ ( - _MDSPAN_TRAIT( std::is_convertible, SizeType, index_type) && + MDSPAN_IMPL_TRAIT( std::is_convertible, SizeType, index_type) && N == extents_type::rank() ) ) MDSPAN_FORCE_INLINE_FUNCTION constexpr const_reference operator[](const std::array& indices) const noexcept { - return __impl::template __callop(*this, indices); + return impl::template callop(*this, indices); } MDSPAN_TEMPLATE_REQUIRES( class SizeType, size_t N, /* requires */ ( - _MDSPAN_TRAIT( std::is_convertible, SizeType, index_type) && + MDSPAN_IMPL_TRAIT( std::is_convertible, SizeType, index_type) && N == extents_type::rank() ) ) MDSPAN_FORCE_INLINE_FUNCTION constexpr reference operator[](const std::array& indices) noexcept { - return __impl::template __callop(*this, indices); + return impl::template callop(*this, indices); } #endif @@ -338,35 +338,35 @@ public: MDSPAN_TEMPLATE_REQUIRES( class SizeType, size_t N, /* requires */ ( - _MDSPAN_TRAIT( std::is_convertible, SizeType, index_type) && + MDSPAN_IMPL_TRAIT( std::is_convertible, SizeType, index_type) && N == extents_type::rank() ) ) MDSPAN_FORCE_INLINE_FUNCTION constexpr const_reference operator()(const std::array& indices) const noexcept { - return __impl::template __callop(*this, indices); + return impl::template callop(*this, indices); } MDSPAN_TEMPLATE_REQUIRES( class SizeType, size_t N, /* requires */ ( - _MDSPAN_TRAIT( std::is_convertible, SizeType, index_type) && + MDSPAN_IMPL_TRAIT( std::is_convertible, SizeType, index_type) && N == extents_type::rank() ) ) MDSPAN_FORCE_INLINE_FUNCTION constexpr reference operator()(const std::array& indices) noexcept { - return __impl::template __callop(*this, indices); + return impl::template callop(*this, indices); } #endif #endif - MDSPAN_INLINE_FUNCTION constexpr pointer data() noexcept { return ctr_.data(); }; - MDSPAN_INLINE_FUNCTION constexpr const_pointer data() const noexcept { return ctr_.data(); }; - MDSPAN_INLINE_FUNCTION constexpr container_type& container() noexcept { return ctr_; }; - MDSPAN_INLINE_FUNCTION constexpr const container_type& container() const noexcept { return ctr_; }; + MDSPAN_INLINE_FUNCTION constexpr pointer data() noexcept { return ctr_.data(); } + MDSPAN_INLINE_FUNCTION constexpr const_pointer data() const noexcept { return ctr_.data(); } + MDSPAN_INLINE_FUNCTION constexpr container_type& container() noexcept { return ctr_; } + MDSPAN_INLINE_FUNCTION constexpr const container_type& container() const noexcept { return ctr_; } //-------------------------------------------------------------------------------- // [mdspan.basic.domobs], mdspan observers of the domain multidimensional index space @@ -375,33 +375,33 @@ public: MDSPAN_INLINE_FUNCTION static constexpr rank_type rank_dynamic() noexcept { return extents_type::rank_dynamic(); } MDSPAN_INLINE_FUNCTION static constexpr size_t static_extent(size_t r) noexcept { return extents_type::static_extent(r); } - MDSPAN_INLINE_FUNCTION constexpr const extents_type& extents() const noexcept { return map_.extents(); }; - MDSPAN_INLINE_FUNCTION constexpr index_type extent(size_t r) const noexcept { return map_.extents().extent(r); }; + MDSPAN_INLINE_FUNCTION constexpr const extents_type& extents() const noexcept { return map_.extents(); } + MDSPAN_INLINE_FUNCTION constexpr index_type extent(size_t r) const noexcept { return map_.extents().extent(r); } MDSPAN_INLINE_FUNCTION constexpr index_type size() const noexcept { -// return __impl::__size(*this); +// return impl::size(*this); return ctr_.size(); - }; + } //-------------------------------------------------------------------------------- // [mdspan.basic.obs], mdspan observers of the mapping - MDSPAN_INLINE_FUNCTION static constexpr bool is_always_unique() noexcept { return mapping_type::is_always_unique(); }; - MDSPAN_INLINE_FUNCTION static constexpr bool is_always_exhaustive() noexcept { return mapping_type::is_always_exhaustive(); }; - MDSPAN_INLINE_FUNCTION static constexpr bool is_always_strided() noexcept { return mapping_type::is_always_strided(); }; + MDSPAN_INLINE_FUNCTION static constexpr bool is_always_unique() noexcept { return mapping_type::is_always_unique(); } + MDSPAN_INLINE_FUNCTION static constexpr bool is_always_exhaustive() noexcept { return mapping_type::is_always_exhaustive(); } + MDSPAN_INLINE_FUNCTION static constexpr bool is_always_strided() noexcept { return mapping_type::is_always_strided(); } - MDSPAN_INLINE_FUNCTION constexpr const mapping_type& mapping() const noexcept { return map_; }; - MDSPAN_INLINE_FUNCTION constexpr bool is_unique() const noexcept { return map_.is_unique(); }; - MDSPAN_INLINE_FUNCTION constexpr bool is_exhaustive() const noexcept { return map_.is_exhaustive(); }; - MDSPAN_INLINE_FUNCTION constexpr bool is_strided() const noexcept { return map_.is_strided(); }; - MDSPAN_INLINE_FUNCTION constexpr index_type stride(size_t r) const { return map_.stride(r); }; + MDSPAN_INLINE_FUNCTION constexpr const mapping_type& mapping() const noexcept { return map_; } + MDSPAN_INLINE_FUNCTION constexpr bool is_unique() const noexcept { return map_.is_unique(); } + MDSPAN_INLINE_FUNCTION constexpr bool is_exhaustive() const noexcept { return map_.is_exhaustive(); } + MDSPAN_INLINE_FUNCTION constexpr bool is_strided() const noexcept { return map_.is_strided(); } + MDSPAN_INLINE_FUNCTION constexpr index_type stride(size_t r) const { return map_.stride(r); } // Converstion to mdspan MDSPAN_TEMPLATE_REQUIRES( class OtherElementType, class OtherExtents, class OtherLayoutType, class OtherAccessorType, /* requires */ ( - _MDSPAN_TRAIT(std::is_assignable, + MDSPAN_IMPL_TRAIT(std::is_assignable, mdspan, mdspan_type) ) @@ -414,7 +414,7 @@ public: class OtherElementType, class OtherExtents, class OtherLayoutType, class OtherAccessorType, /* requires */ ( - _MDSPAN_TRAIT(std::is_assignable, + MDSPAN_IMPL_TRAIT(std::is_assignable, mdspan, const_mdspan_type) ) @@ -426,7 +426,7 @@ public: MDSPAN_TEMPLATE_REQUIRES( class OtherAccessorType = default_accessor, /* requires */ ( - _MDSPAN_TRAIT(std::is_assignable, mdspan_type, + MDSPAN_IMPL_TRAIT(std::is_assignable, mdspan_type, mdspan) ) ) @@ -438,7 +438,7 @@ public: MDSPAN_TEMPLATE_REQUIRES( class OtherAccessorType = default_accessor, /* requires */ ( - _MDSPAN_TRAIT(std::is_assignable, const_mdspan_type, + MDSPAN_IMPL_TRAIT(std::is_assignable, const_mdspan_type, mdspan) ) ) diff --git a/ext/mdspan/include/experimental/__p2630_bits/strided_slice.hpp b/ext/mdspan/include/experimental/__p2630_bits/strided_slice.hpp index 89ba820..7f4a018 100644 --- a/ext/mdspan/include/experimental/__p2630_bits/strided_slice.hpp +++ b/ext/mdspan/include/experimental/__p2630_bits/strided_slice.hpp @@ -21,12 +21,12 @@ namespace MDSPAN_IMPL_STANDARD_NAMESPACE { -namespace { +namespace detail { template - struct __mdspan_is_integral_constant: std::false_type {}; + struct mdspan_is_integral_constant: std::false_type {}; template - struct __mdspan_is_integral_constant>: std::true_type {}; + struct mdspan_is_integral_constant>: std::true_type {}; } // Slice Specifier allowing for strides and compile time extent @@ -36,13 +36,13 @@ struct strided_slice { using extent_type = ExtentType; using stride_type = StrideType; - _MDSPAN_NO_UNIQUE_ADDRESS OffsetType offset{}; - _MDSPAN_NO_UNIQUE_ADDRESS ExtentType extent{}; - _MDSPAN_NO_UNIQUE_ADDRESS StrideType stride{}; + MDSPAN_IMPL_NO_UNIQUE_ADDRESS OffsetType offset{}; + MDSPAN_IMPL_NO_UNIQUE_ADDRESS ExtentType extent{}; + MDSPAN_IMPL_NO_UNIQUE_ADDRESS StrideType stride{}; - static_assert(std::is_integral_v || __mdspan_is_integral_constant::value); - static_assert(std::is_integral_v || __mdspan_is_integral_constant::value); - static_assert(std::is_integral_v || __mdspan_is_integral_constant::value); + static_assert(std::is_integral_v || detail::mdspan_is_integral_constant::value); + static_assert(std::is_integral_v || detail::mdspan_is_integral_constant::value); + static_assert(std::is_integral_v || detail::mdspan_is_integral_constant::value); }; } // MDSPAN_IMPL_STANDARD_NAMESPACE diff --git a/ext/mdspan/include/experimental/__p2630_bits/submdspan_mapping.hpp b/ext/mdspan/include/experimental/__p2630_bits/submdspan_mapping.hpp index 46ccbaa..3a87dff 100644 --- a/ext/mdspan/include/experimental/__p2630_bits/submdspan_mapping.hpp +++ b/ext/mdspan/include/experimental/__p2630_bits/submdspan_mapping.hpp @@ -46,7 +46,7 @@ namespace MDSPAN_IMPL_STANDARD_NAMESPACE { // Return type of submdspan_mapping overloads //****************************************** template struct submdspan_mapping_result { - _MDSPAN_NO_UNIQUE_ADDRESS LayoutMapping mapping{}; + MDSPAN_IMPL_NO_UNIQUE_ADDRESS LayoutMapping mapping{}; size_t offset; }; @@ -72,7 +72,7 @@ MDSPAN_INLINE_FUNCTION constexpr bool any_slice_out_of_bounds_helper(std::index_sequence, const extents &exts, const Slices &... slices) { - return _MDSPAN_FOLD_OR( + return MDSPAN_IMPL_FOLD_OR( (one_slice_out_of_bounds(exts.extent(RankIndices), slices))); } @@ -182,7 +182,7 @@ struct deduce_layout_left_submapping< // e.g. R I I I F F F R I I for obtaining a rank-5 from a rank-10 return ((((Idx == 0) && is_range_slice_v) || ((Idx > 0 && Idx <= gap_len) && is_index_slice_v) || - ((Idx > gap_len && Idx < gap_len + SubRank - 1) && std::is_same_v) || + ((Idx > gap_len && Idx < gap_len + SubRank - 1) && std::is_same_v) || ((Idx == gap_len + SubRank - 1) && is_range_slice_v) || ((Idx > gap_len + SubRank - 1) && is_index_slice_v)) && ... ); } @@ -190,18 +190,15 @@ struct deduce_layout_left_submapping< // We are reusing the same thing for layout_left and layout_left_padded // For layout_left as source StaticStride is static_extent(0) -template -struct compute_s_static_layout_left { +template +MDSPAN_INLINE_FUNCTION constexpr size_t +compute_s_static_layout_left(std::index_sequence) { // Neither StaticStride nor any of the provided extents can be zero. // StaticStride can never be zero, the static_extents we are looking at are associated with // integral slice specifiers - which wouldn't be valid for zero extent - template - MDSPAN_INLINE_FUNCTION - static constexpr size_t value(std::index_sequence) { size_t val = ((Idx>0 && Idx<=NumGaps ? (Extents::static_extent(Idx) == dynamic_extent?0:Extents::static_extent(Idx)) : 1) * ... * (StaticStride == dynamic_extent?0:StaticStride)); return val == 0?dynamic_extent:val; } -}; } // namespace detail @@ -237,7 +234,7 @@ layout_left::mapping::submdspan_mapping_impl( return submdspan_mapping_result{dst_mapping_t(dst_ext), offset}; } else if constexpr (deduce_layout::layout_left_padded_value()) { - constexpr size_t S_static = MDSPAN_IMPL_STANDARD_NAMESPACE::detail::compute_s_static_layout_left::value(std::make_index_sequence()); + constexpr size_t S_static = MDSPAN_IMPL_STANDARD_NAMESPACE::detail::compute_s_static_layout_left(std::make_index_sequence()); using dst_mapping_t = typename MDSPAN_IMPL_PROPOSED_NAMESPACE::layout_left_padded::template mapping; return submdspan_mapping_result{ dst_mapping_t(dst_ext, stride(1 + deduce_layout::gap_len)), offset}; @@ -254,7 +251,7 @@ layout_left::mapping::submdspan_mapping_impl( // NVCC 11.0 has a bug with deduction guide here, tested that 11.2 does not have // the issue but Clang-CUDA also doesn't accept the use of deduction guide so // disable it for CUDA altogether -#if defined(_MDSPAN_HAS_HIP) || defined(_MDSPAN_HAS_CUDA) +#if defined(MDSPAN_IMPL_HAS_HIP) || defined(MDSPAN_IMPL_HAS_CUDA) detail::tuple{ detail::stride_of(slices)...}).values), #else @@ -316,7 +313,7 @@ MDSPAN_IMPL_PROPOSED_NAMESPACE::layout_left_padded::mapping; return submdspan_mapping_result{dst_mapping_t{dst_ext}, offset}; } else if constexpr (deduce_layout::layout_left_padded_value()) { // can keep layout_left_padded - constexpr size_t S_static = MDSPAN_IMPL_STANDARD_NAMESPACE::detail::compute_s_static_layout_left::value(std::make_index_sequence()); + constexpr size_t S_static = MDSPAN_IMPL_STANDARD_NAMESPACE::detail::compute_s_static_layout_left(std::make_index_sequence()); using dst_mapping_t = typename MDSPAN_IMPL_PROPOSED_NAMESPACE::layout_left_padded::template mapping; return submdspan_mapping_result{ dst_mapping_t(dst_ext, stride(1 + deduce_layout::gap_len)), offset}; @@ -332,7 +329,7 @@ MDSPAN_IMPL_PROPOSED_NAMESPACE::layout_left_padded::mapping{ MDSPAN_IMPL_STANDARD_NAMESPACE::detail::stride_of(slices)...}).values), #else @@ -421,18 +418,15 @@ struct deduce_layout_right_submapping< // We are reusing the same thing for layout_right and layout_right_padded // For layout_right as source StaticStride is static_extent(Rank-1) -template -struct compute_s_static_layout_right { +template +MDSPAN_INLINE_FUNCTION constexpr size_t +compute_s_static_layout_right (std::index_sequence) { // Neither StaticStride nor any of the provided extents can be zero. // StaticStride can never be zero, the static_extents we are looking at are associated with // integral slice specifiers - which wouldn't be valid for zero extent - template - MDSPAN_INLINE_FUNCTION - static constexpr size_t value(std::index_sequence) { size_t val = ((Idx >= Extents::rank() - 1 - NumGaps && Idx < Extents::rank() - 1 ? (Extents::static_extent(Idx) == dynamic_extent?0:Extents::static_extent(Idx)) : 1) * ... * (StaticStride == dynamic_extent?0:StaticStride)); return val == 0?dynamic_extent:val; } -}; } // namespace detail @@ -468,7 +462,7 @@ layout_right::mapping::submdspan_mapping_impl( return submdspan_mapping_result{dst_mapping_t(dst_ext), offset}; } else if constexpr (deduce_layout::layout_right_padded_value()) { - constexpr size_t S_static = MDSPAN_IMPL_STANDARD_NAMESPACE::detail::compute_s_static_layout_left::value(std::make_index_sequence()); + constexpr size_t S_static = MDSPAN_IMPL_STANDARD_NAMESPACE::detail::compute_s_static_layout_left(std::make_index_sequence()); using dst_mapping_t = typename MDSPAN_IMPL_PROPOSED_NAMESPACE::layout_right_padded::template mapping; return submdspan_mapping_result{ dst_mapping_t(dst_ext, @@ -487,7 +481,7 @@ layout_right::mapping::submdspan_mapping_impl( // NVCC 11.0 has a bug with deduction guide here, tested that 11.2 does not have // the issue but Clang-CUDA also doesn't accept the use of deduction guide so // disable it for CUDA altogether -#if defined(_MDSPAN_HAS_HIP) || defined(_MDSPAN_HAS_CUDA) +#if defined(MDSPAN_IMPL_HAS_HIP) || defined(MDSPAN_IMPL_HAS_CUDA) MDSPAN_IMPL_STANDARD_NAMESPACE::detail::tuple{ detail::stride_of(slices)...}).values), #else @@ -541,7 +535,7 @@ MDSPAN_IMPL_PROPOSED_NAMESPACE::layout_right_padded::mapping; return submdspan_mapping_result{dst_mapping_t{dst_ext}, offset}; } else if constexpr (deduce_layout::layout_right_padded_value()) { // can keep layout_right_padded - constexpr size_t S_static = MDSPAN_IMPL_STANDARD_NAMESPACE::detail::compute_s_static_layout_right::value(std::make_index_sequence()); + constexpr size_t S_static = MDSPAN_IMPL_STANDARD_NAMESPACE::detail::compute_s_static_layout_right(std::make_index_sequence()); using dst_mapping_t = typename MDSPAN_IMPL_PROPOSED_NAMESPACE::layout_right_padded::template mapping; return submdspan_mapping_result{ dst_mapping_t(dst_ext, stride(Extents::rank() - 2 - deduce_layout::gap_len)), offset}; @@ -557,7 +551,7 @@ MDSPAN_IMPL_PROPOSED_NAMESPACE::layout_right_padded::mapping{ MDSPAN_IMPL_STANDARD_NAMESPACE::detail::stride_of(slices)...}).values), #else @@ -605,7 +599,7 @@ layout_stride::mapping::submdspan_mapping_impl( // NVCC 11.0 has a bug with deduction guide here, tested that 11.2 does not have // the issue but Clang-CUDA also doesn't accept the use of deduction guide so // disable it for CUDA alltogether -#if defined(_MDSPAN_HAS_HIP) || defined(_MDSPAN_HAS_CUDA) +#if defined(MDSPAN_IMPL_HAS_HIP) || defined(MDSPAN_IMPL_HAS_CUDA) MDSPAN_IMPL_STANDARD_NAMESPACE::detail::tuple( detail::stride_of(slices)...)).values), #else diff --git a/ext/mdspan/include/experimental/__p2642_bits/layout_padded.hpp b/ext/mdspan/include/experimental/__p2642_bits/layout_padded.hpp index a714090..d91313b 100644 --- a/ext/mdspan/include/experimental/__p2642_bits/layout_padded.hpp +++ b/ext/mdspan/include/experimental/__p2642_bits/layout_padded.hpp @@ -27,36 +27,43 @@ namespace MDSPAN_IMPL_STANDARD_NAMESPACE { namespace MDSPAN_IMPL_PROPOSED_NAMESPACE { - namespace detail { -template +template MDSPAN_INLINE_FUNCTION -constexpr _T -find_next_multiple(_T alignment, _T offset) +constexpr T +find_next_multiple(T alignment, U offset) { - if ( alignment == 0 ) { - return _T(0); + if ( alignment == T(0) ) { + return T(0); } else { return ( ( offset + alignment - 1 ) / alignment) * alignment; } } -template +template MDSPAN_INLINE_FUNCTION constexpr size_t get_actual_static_padding_value() { - constexpr auto rank = _ExtentsType::rank(); + using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::in_range; + constexpr auto rank = ExtentsType::rank(); - if constexpr (rank <= typename _ExtentsType::rank_type(1)) { + if constexpr (rank <= typename ExtentsType::rank_type(1)) { return 0; - } else if constexpr (_PaddingValue != dynamic_extent && - _ExtentsType::static_extent(_ExtentToPadIdx) != + } else if constexpr (PaddingValue != dynamic_extent && + ExtentsType::static_extent(ExtentToPadIdx) != dynamic_extent) { static_assert( - (_PaddingValue != 0) || - (_ExtentsType::static_extent(_ExtentToPadIdx) == 0), + (PaddingValue != 0) || + (ExtentsType::static_extent(ExtentToPadIdx) == 0), "padding stride can be 0 only if " "extents_type::static_extent(extent-to-pad) is 0 or dynamic_extent"); - return find_next_multiple(_PaddingValue, - _ExtentsType::static_extent(_ExtentToPadIdx)); + constexpr auto ret = find_next_multiple( + PaddingValue, ExtentsType::static_extent(ExtentToPadIdx)); + + using index_type = typename ExtentsType::index_type; + static_assert(in_range(ret), + "The least multiple of padding_value and first-static-extent " + "must be representable by index_type"); + + return ret; } else { return dynamic_extent; } @@ -66,44 +73,46 @@ MDSPAN_INLINE_FUNCTION constexpr size_t get_actual_static_padding_value() { #endif } -template -struct static_array_type_for_padded_extent -{ - static constexpr size_t padding_value = _PaddingValue; - using index_type = typename _Extents::index_type; - using extents_type = _Extents; +template +struct static_array_type_for_padded_extent { + static constexpr size_t padding_value = PaddingValue; + using index_type = typename Extents::index_type; + using extents_type = Extents; using type = ::MDSPAN_IMPL_STANDARD_NAMESPACE::detail::maybe_static_array< index_type, size_t, dynamic_extent, - ::MDSPAN_IMPL_STANDARD_NAMESPACE::MDSPAN_IMPL_PROPOSED_NAMESPACE::detail::get_actual_static_padding_value()>; + ::MDSPAN_IMPL_STANDARD_NAMESPACE::MDSPAN_IMPL_PROPOSED_NAMESPACE::detail:: + get_actual_static_padding_value()>; }; -template -struct static_array_type_for_padded_extent<_PaddingValue, _Extents, - _ExtentToPadIdx, Rank, std::enable_if_t> { - using index_type = typename _Extents::index_type; - using extents_type = _Extents; - using type = - ::MDSPAN_IMPL_STANDARD_NAMESPACE::detail::maybe_static_array< - index_type, size_t, dynamic_extent, 0>; +template +struct static_array_type_for_padded_extent< + PaddingValue, Extents, ExtentToPadIdx, Rank, std::enable_if_t> { + using index_type = typename Extents::index_type; + using extents_type = Extents; + using type = ::MDSPAN_IMPL_STANDARD_NAMESPACE::detail::maybe_static_array< + index_type, size_t, dynamic_extent, 0>; }; -template +template struct padded_extent { - static constexpr size_t padding_value = _PaddingValue; - using index_type = typename _Extents::index_type; - using extents_type = _Extents; + static constexpr size_t padding_value = PaddingValue; + using index_type = typename Extents::index_type; + using extents_type = Extents; using static_array_type = typename static_array_type_for_padded_extent< - padding_value, _Extents, _ExtentToPadIdx, _Extents::rank()>::type; + padding_value, Extents, ExtentToPadIdx, Extents::rank()>::type; MDSPAN_INLINE_FUNCTION - static constexpr auto static_value() { return static_array_type::static_value(0); } + static constexpr auto static_value() { + return static_array_type::static_value(0); + } MDSPAN_INLINE_FUNCTION - static constexpr static_array_type - init_padding(const _Extents &exts) { - if constexpr ((_Extents::rank() > 1) && (padding_value == dynamic_extent)) { - return {exts.extent(_ExtentToPadIdx)}; + static constexpr static_array_type init_padding(const Extents &exts) { + if constexpr ((Extents::rank() > 1) && (padding_value == dynamic_extent)) { + return {exts.extent(ExtentToPadIdx)}; } else { return init_padding(exts, padding_value); } @@ -114,11 +123,13 @@ struct padded_extent { } MDSPAN_INLINE_FUNCTION static constexpr static_array_type - init_padding([[maybe_unused]] const _Extents &exts, - [[maybe_unused]] index_type pv) { - if constexpr (_Extents::rank() > 1) { - return {find_next_multiple(pv, - exts.extent(_ExtentToPadIdx))}; + init_padding([[maybe_unused]] const Extents &exts, + [[maybe_unused]] size_t pv) { + using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::in_range; + if constexpr (Extents::rank() > 1) { + auto strd = find_next_multiple(pv, exts.extent(ExtentToPadIdx)); + MDSPAN_IMPL_PRECONDITION(in_range(strd)); + return {strd}; } else { return {}; } @@ -128,12 +139,12 @@ struct padded_extent { #endif } - template + template MDSPAN_INLINE_FUNCTION static constexpr static_array_type - init_padding([[maybe_unused]] const _Mapping &other_mapping, - std::integral_constant) { - if constexpr (_Extents::rank() > 1) { - return {other_mapping.stride(_PaddingStrideIdx)}; + init_padding([[maybe_unused]] const Mapping &other_mapping, + std::integral_constant) { + if constexpr (Extents::rank() > 1) { + return {other_mapping.stride(PaddingStrideIdx)}; } else { return {}; } @@ -143,6 +154,148 @@ struct padded_extent { #endif } }; + +template +MDSPAN_INLINE_FUNCTION constexpr bool +check_static_extents_representability() { + using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::check_mul_result_is_nonnegative_and_representable; + // We cannot check statically for sure if the extents are representable + // if we have dynamic values -- this can only be checked by a precondition + // We can check if the product of only the static extents is representable though... + using index_type = typename Extents::index_type; + + // get rid of NVCC warning "pointless comparison of unsigned integer with zero" + if constexpr ( Extents::rank() > 0 ) { + auto prod = index_type(1); + for (size_t i = 0; i < Extents::rank(); ++i) { + if (Extents::static_extent(i) == dynamic_extent) + continue; + if (!check_mul_result_is_nonnegative_and_representable( + prod, static_cast(Extents::static_extent(i)))) + return false; + prod *= Extents::static_extent(i); + } + } + + return true; +} + +template +MDSPAN_INLINE_FUNCTION constexpr bool +check_extents_representability(const Extents &exts) { + using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::check_mul_result_is_nonnegative_and_representable; + using index_type = typename Extents::index_type; + + // get rid of NVCC warning "pointless comparison of unsigned integer with zero" + if constexpr ( Extents::rank() > 0 ) { + auto prod = index_type(1); + for (size_t i = 0; i < Extents::rank(); ++i) { + if (!check_mul_result_is_nonnegative_and_representable( + prod, static_cast(exts.extent(i)))) + return false; + prod *= exts.extent(i); + } + } + + return true; +} + +template +MDSPAN_INLINE_FUNCTION constexpr bool +check_static_extents_and_left_padding_representability() { + using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::check_mul_result_is_nonnegative_and_representable; + if constexpr (Extents::rank() < 2) { + return true; + } + + // We cannot check statically for sure if the product of the extents and padding value + // are representable if we have dynamic values -- this can only be checked by a precondition + // We can check if the product of only the static extents and potentially the padding value (if it is static) + // is representable though... + // We already checked that StaticPaddingValue is representable by index_type + + // get rid of NVCC warning "pointless comparison of unsigned integer with zero" + if constexpr ( Extents::rank() > 0 ) { + auto prod = (StaticPaddingValue != dynamic_extent) ? static_cast< CheckType >(StaticPaddingValue) : CheckType(1); + for (size_t i = 1; i < Extents::rank(); ++i) { + if (Extents::static_extent(i) == dynamic_extent) + continue; + if (!check_mul_result_is_nonnegative_and_representable(prod, static_cast< CheckType >(Extents::static_extent(i)))) + return false; + prod *= Extents::static_extent(i); + } + } + + return true; +} + +template +MDSPAN_INLINE_FUNCTION constexpr bool +check_extents_and_left_padding_representability(const Extents &exts, + [[maybe_unused]] size_t dynamic_padding_value) { + using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::check_mul_result_is_nonnegative_and_representable; + + // get rid of NVCC warning "pointless comparison of unsigned integer with zero" + // And also a rank 1 layout cannot overflow + if constexpr ( Extents::rank() > 1 ) { + auto prod = static_cast(dynamic_padding_value); + for (size_t i = 1; i < Extents::rank(); ++i) { + if (!check_mul_result_is_nonnegative_and_representable( + prod, static_cast(exts.extent(i)))) + return false; + prod *= exts.extent(i); + } + } + + return true; +} + +template +MDSPAN_INLINE_FUNCTION constexpr bool +check_static_extents_and_right_padding_representability() { + using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::check_mul_result_is_nonnegative_and_representable; + + // We cannot check statically for sure if the product of the extents and padding value + // are representable if we have dynamic values -- this can only be checked by a precondition + // We can check if the product of only the static extents and potentially the padding value (if it is static) + // is representable though... + // We already checked that StaticPaddingValue is representable by index_type + + // get rid of NVCC warning "pointless comparison of unsigned integer with zero" + // And also a rank 1 layout cannot overflow + if constexpr ( Extents::rank() > 1 ) { + auto prod = (StaticPaddingValue != dynamic_extent) ? static_cast< CheckType >(StaticPaddingValue) : CheckType(1); + for (size_t i = 0; i < Extents::rank() - 1; ++i) { + if (Extents::static_extent(i) == dynamic_extent) + continue; + if (!check_mul_result_is_nonnegative_and_representable(prod, static_cast< CheckType >(Extents::static_extent(i)))) + return false; + prod *= Extents::static_extent(i); + } + } + + return true; +} + +template +MDSPAN_INLINE_FUNCTION constexpr bool +check_extents_and_right_padding_representability(const Extents &exts, + [[maybe_unused]] size_t dynamic_padding_value) { + using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::check_mul_result_is_nonnegative_and_representable; + + // get rid of NVCC warning "pointless comparison of unsigned integer with zero" + // And also a rank 1 layout cannot overflow + if constexpr ( Extents::rank() > 1 ) { + auto prod = static_cast(dynamic_padding_value); + for (size_t i = 0; i < Extents::rank() - 1; ++i) { + if (!check_mul_result_is_nonnegative_and_representable(prod, static_cast< CheckType >(exts.extent(i)))) + return false; + prod *= exts.extent(i); + } + } + + return true; +} } // namespace detail template @@ -168,11 +321,17 @@ private: || (extents_type::static_extent(extent_to_pad_idx) == 0) || (extents_type::static_extent(extent_to_pad_idx) == dynamic_extent), "out of bounds access for rank 0"); + static_assert(detail::check_static_extents_representability(), "The size of the muiltidimensional index space given by the extents must be representable as a value of index_type"); + static_assert((padding_value == dynamic_extent) || MDSPAN_IMPL_STANDARD_NAMESPACE::detail::in_range(padding_value), "padding_value must be representable as a value of type index_type"); using padded_stride_type = detail::padded_extent< padding_value, extents_type, extent_to_pad_idx >; static constexpr size_t static_padding_stride = padded_stride_type::static_value(); + static_assert(detail::check_static_extents_and_left_padding_representability() + && detail::check_static_extents_and_left_padding_representability(), + "the product of static_padding_stride and static extents 1 through rank must be representable as a value of type size_t and index_type"); + typename padded_stride_type::static_array_type padded_stride = {}; extents_type exts = {}; @@ -233,7 +392,12 @@ public: MDSPAN_INLINE_FUNCTION constexpr mapping(const extents_type& ext) : padded_stride(padded_stride_type::init_padding(ext)), exts(ext) - {} + { + MDSPAN_IMPL_PRECONDITION(detail::check_extents_representability(ext)); + MDSPAN_IMPL_PRECONDITION( + detail::check_extents_and_left_padding_representability( + ext, padded_stride.value(0))); + } /** * Initializes the mapping with the given extents and the specified padding value. @@ -245,17 +409,21 @@ public: * \param padding_value the padding value */ MDSPAN_TEMPLATE_REQUIRES( - class _Size, + class Size, /* requires */ ( - std::is_convertible_v<_Size, index_type> - && std::is_nothrow_constructible_v + std::is_convertible_v + && std::is_nothrow_constructible_v ) ) MDSPAN_INLINE_FUNCTION - constexpr mapping(const extents_type &ext, _Size dynamic_padding_value) + constexpr mapping(const extents_type &ext, Size dynamic_padding_value) : padded_stride(padded_stride_type::init_padding(ext, dynamic_padding_value)), exts(ext) { assert((padding_value == dynamic_extent) || (static_cast(padding_value) == static_cast(dynamic_padding_value))); + MDSPAN_IMPL_PRECONDITION(detail::check_extents_representability(ext)); + MDSPAN_IMPL_PRECONDITION( + detail::check_extents_and_left_padding_representability( + ext, dynamic_padding_value)); } /** @@ -269,22 +437,26 @@ public: * `padding_value` greater than or equal to `extents_type::static_extent(0)` */ MDSPAN_TEMPLATE_REQUIRES( - class _OtherExtents, - /* requires */ (std::is_constructible_v)) + class OtherExtents, + /* requires */ (std::is_constructible_v)) MDSPAN_CONDITIONAL_EXPLICIT( - (!std::is_convertible_v<_OtherExtents, extents_type>)) + (!std::is_convertible_v)) MDSPAN_INLINE_FUNCTION - constexpr mapping(const layout_left::mapping<_OtherExtents> &other_mapping) + constexpr mapping(const layout_left::mapping &other_mapping) : padded_stride(padded_stride_type::init_padding( other_mapping, std::integral_constant{})), exts(other_mapping.extents()) { static_assert( - (_OtherExtents::rank() > 1) || + (OtherExtents::rank() > 1) || (static_padding_stride != dynamic_extent) || - (_OtherExtents::static_extent(extent_to_pad_idx) != dynamic_extent) || + (OtherExtents::static_extent(extent_to_pad_idx) != dynamic_extent) || (static_padding_stride == - _OtherExtents::static_extent(extent_to_pad_idx))); + OtherExtents::static_extent(extent_to_pad_idx))); + MDSPAN_IMPL_PRECONDITION(detail::check_extents_representability(exts)); + MDSPAN_IMPL_PRECONDITION( + detail::check_extents_and_left_padding_representability( + exts, padded_stride.value(0))); } /** @@ -294,15 +466,20 @@ public: * `is_constructible_v` is true */ MDSPAN_TEMPLATE_REQUIRES( - class _OtherExtents, - /* requires */ (std::is_constructible_v)) + class OtherExtents, + /* requires */ (std::is_constructible_v)) MDSPAN_CONDITIONAL_EXPLICIT((extents_type::rank() > 0)) MDSPAN_INLINE_FUNCTION - constexpr mapping(const layout_stride::mapping<_OtherExtents> &other_mapping) + constexpr mapping(const layout_stride::mapping &other_mapping) : padded_stride(padded_stride_type::init_padding( other_mapping, std::integral_constant{})), - exts(other_mapping.extents()) {} + exts(other_mapping.extents()) { + MDSPAN_IMPL_PRECONDITION(detail::check_extents_representability(exts)); + MDSPAN_IMPL_PRECONDITION( + detail::check_extents_and_left_padding_representability( + exts, padded_stride.value(0))); + } /** * Converting constructor from `layout_left_padded::mapping`. @@ -313,22 +490,26 @@ public: * `padding_value == OtherPaddingStride`. */ MDSPAN_TEMPLATE_REQUIRES( - class _Mapping, - /* requires */ (detail::is_layout_left_padded_mapping<_Mapping>::value + class Mapping, + /* requires */ (detail::is_layout_left_padded_mapping::value &&std::is_constructible_v< - extents_type, typename _Mapping::extents_type>)) + extents_type, typename Mapping::extents_type>)) MDSPAN_CONDITIONAL_EXPLICIT((extents_type::rank() > 1 && (padding_value == dynamic_extent || - _Mapping::padding_value == dynamic_extent))) + Mapping::padding_value == dynamic_extent))) MDSPAN_INLINE_FUNCTION - constexpr mapping(const _Mapping &other_mapping) + constexpr mapping(const Mapping &other_mapping) : padded_stride(padded_stride_type::init_padding( other_mapping, std::integral_constant{})), exts(other_mapping.extents()) { static_assert(padding_value == dynamic_extent || - _Mapping::padding_value == dynamic_extent || - padding_value == _Mapping::padding_value); + Mapping::padding_value == dynamic_extent || + padding_value == Mapping::padding_value); + MDSPAN_IMPL_PRECONDITION(detail::check_extents_representability(exts)); + MDSPAN_IMPL_PRECONDITION( + detail::check_extents_and_left_padding_representability( + exts, padded_stride.value(0))); } /** @@ -339,19 +520,24 @@ public: * OtherExtents>` is `true`. */ MDSPAN_TEMPLATE_REQUIRES( - class _Mapping, - /* requires */ (detail::is_layout_right_padded_mapping<_Mapping>::value + class Mapping, + /* requires */ (detail::is_layout_right_padded_mapping::value &&extents_type::rank() <= 1 && std::is_constructible_v)) + typename Mapping::extents_type>)) MDSPAN_CONDITIONAL_EXPLICIT( - (!std::is_convertible_v)) + (!std::is_convertible_v)) MDSPAN_INLINE_FUNCTION - constexpr mapping(const _Mapping &other_mapping) noexcept + constexpr mapping(const Mapping &other_mapping) noexcept : padded_stride(padded_stride_type::init_padding( static_cast(other_mapping.extents()), other_mapping.extents().extent(extent_to_pad_idx))), - exts(other_mapping.extents()) {} + exts(other_mapping.extents()) { + MDSPAN_IMPL_PRECONDITION(detail::check_extents_representability(exts)); + MDSPAN_IMPL_PRECONDITION( + detail::check_extents_and_left_padding_representability( + exts, padded_stride.value(0))); + } MDSPAN_INLINE_FUNCTION constexpr const extents_type & extents() const noexcept { @@ -390,7 +576,7 @@ public: for (rank_type r = 1; r < extents_type::rank(); ++r) { value *= exts.extent(r); } - return value; + return value == 0 ? 0 : value + exts.extent(0) - padded_stride.value(0); } } @@ -403,17 +589,17 @@ public: * - (is_nothrow_constructible_v && ...) is true. */ MDSPAN_TEMPLATE_REQUIRES( - class... _Indices, - /* requires */ (sizeof...(_Indices) == extents_type::rank() && + class... Indices, + /* requires */ (sizeof...(Indices) == extents_type::rank() && (::MDSPAN_IMPL_STANDARD_NAMESPACE::detail:: - are_valid_indices()))) + are_valid_indices()))) MDSPAN_INLINE_FUNCTION constexpr size_t - operator()(_Indices... idxs) const noexcept { + operator()(Indices... idxs) const noexcept { #if !defined(NDEBUG) ::MDSPAN_IMPL_STANDARD_NAMESPACE::detail::check_all_indices(this->extents(), idxs...); #endif // ! NDEBUG - return compute_offset(std::index_sequence_for<_Indices...>{}, idxs...); + return compute_offset(std::index_sequence_for{}, idxs...); } MDSPAN_INLINE_FUNCTION static constexpr bool is_always_unique() noexcept { @@ -464,11 +650,11 @@ public: * Extents>`. However, this makes `padding_value` non-deducible. */ MDSPAN_TEMPLATE_REQUIRES( - class _Mapping, - /* requires */ (detail::is_layout_left_padded_mapping<_Mapping>::value && - (_Mapping::extents_type::rank() == extents_type::rank()))) + class Mapping, + /* requires */ (detail::is_layout_left_padded_mapping::value && + (Mapping::extents_type::rank() == extents_type::rank()))) MDSPAN_INLINE_FUNCTION friend constexpr bool - operator==(const mapping &left, const _Mapping &right) noexcept { + operator==(const mapping &left, const Mapping &right) noexcept { // Workaround for some compilers not short-circuiting properly with // compile-time checks i.e. we can't access stride(_padding_stride_idx) of a // rank 0 mapping @@ -488,11 +674,11 @@ public: * `OtherExtents::rank() == extents_type::rank()`. */ MDSPAN_TEMPLATE_REQUIRES( - class _Mapping, - /* requires */ (detail::is_layout_left_padded_mapping<_Mapping>::value && - (_Mapping::extents_type::rank() == extents_type::rank()))) + class Mapping, + /* requires */ (detail::is_layout_left_padded_mapping::value && + (Mapping::extents_type::rank() == extents_type::rank()))) MDSPAN_INLINE_FUNCTION friend constexpr bool - operator!=(const mapping &left, const _Mapping &right) noexcept { + operator!=(const mapping &left, const Mapping &right) noexcept { return !(left == right); } #endif @@ -534,10 +720,17 @@ public: || (extents_type::static_extent(extent_to_pad_idx) == 0) || (extents_type::static_extent(extent_to_pad_idx) == dynamic_extent), "if padding stride is 0, static_extent(extent-to-pad-rank) must also be 0 or dynamic_extent"); + static_assert(detail::check_static_extents_representability(), "The size of the muiltidimensional index space given by the extents must be representable as a value of index_type"); + static_assert((padding_value == dynamic_extent) || MDSPAN_IMPL_STANDARD_NAMESPACE::detail::in_range(padding_value), "padding_value must be representable as a value of type index_type"); + using padded_stride_type = detail::padded_extent< padding_value, extents_type, extent_to_pad_idx >; static constexpr size_t static_padding_stride = padded_stride_type::static_value(); + static_assert(detail::check_static_extents_and_right_padding_representability() + && detail::check_static_extents_and_right_padding_representability(), + "the product of static_padding_stride and static extents 1 through rank must be representable as a value of type size_t and index_type"); + typename padded_stride_type::static_array_type padded_stride = {}; extents_type exts = {}; @@ -595,7 +788,12 @@ public: */ MDSPAN_INLINE_FUNCTION constexpr mapping(const extents_type &ext) - : padded_stride(padded_stride_type::init_padding(ext)), exts(ext) {} + : padded_stride(padded_stride_type::init_padding(ext)), exts(ext) { + MDSPAN_IMPL_PRECONDITION(detail::check_extents_representability(ext)); + MDSPAN_IMPL_PRECONDITION( + detail::check_extents_and_right_padding_representability( + ext, padded_stride.value(0))); + } /** * Initializes the mapping with the given extents and the specified padding value. @@ -607,18 +805,22 @@ public: * \param padding_value the padding value */ MDSPAN_TEMPLATE_REQUIRES( - class _Size, + class Size, /* requires */ ( - std::is_convertible_v<_Size, index_type> - && std::is_nothrow_constructible_v + std::is_convertible_v + && std::is_nothrow_constructible_v ) ) MDSPAN_INLINE_FUNCTION - constexpr mapping(const extents_type &ext, _Size dynamic_padding_value) + constexpr mapping(const extents_type &ext, Size dynamic_padding_value) : padded_stride(padded_stride_type::init_padding(ext, static_cast(dynamic_padding_value))), exts(ext) { assert((padding_value == dynamic_extent) || (static_cast(padding_value) == static_cast(dynamic_padding_value))); + MDSPAN_IMPL_PRECONDITION(detail::check_extents_representability(ext)); + MDSPAN_IMPL_PRECONDITION( + detail::check_extents_and_right_padding_representability( + ext, dynamic_padding_value)); } /** @@ -629,22 +831,26 @@ public: * otherwise, `OtherExtents::static_extent(0)` must be equal to the least multiple of `padding_value` greater than or equal to `extents_type::static_extent(0)` */ MDSPAN_TEMPLATE_REQUIRES( - class _OtherExtents, - /* requires */ (std::is_constructible_v)) + class OtherExtents, + /* requires */ (std::is_constructible_v)) MDSPAN_CONDITIONAL_EXPLICIT( - (!std::is_convertible_v<_OtherExtents, extents_type>)) + (!std::is_convertible_v)) MDSPAN_INLINE_FUNCTION - constexpr mapping(const layout_right::mapping<_OtherExtents> &other_mapping) + constexpr mapping(const layout_right::mapping &other_mapping) : padded_stride(padded_stride_type::init_padding( other_mapping, std::integral_constant{})), exts(other_mapping.extents()) { static_assert( - (_OtherExtents::rank() > 1) || + (OtherExtents::rank() > 1) || (padded_stride_type::static_value() != dynamic_extent) || - (_OtherExtents::static_extent(extent_to_pad_idx) != dynamic_extent) || + (OtherExtents::static_extent(extent_to_pad_idx) != dynamic_extent) || (padded_stride_type::static_value() == - _OtherExtents::static_extent(extent_to_pad_idx))); + OtherExtents::static_extent(extent_to_pad_idx))); + MDSPAN_IMPL_PRECONDITION(detail::check_extents_representability(exts)); + MDSPAN_IMPL_PRECONDITION( + detail::check_extents_and_right_padding_representability( + exts, padded_stride.value(0))); } /** @@ -654,15 +860,20 @@ public: * `is_constructible_v` is true */ MDSPAN_TEMPLATE_REQUIRES( - class _OtherExtents, - /* requires */ (std::is_constructible_v)) + class OtherExtents, + /* requires */ (std::is_constructible_v)) MDSPAN_CONDITIONAL_EXPLICIT((extents_type::rank() > 0)) MDSPAN_INLINE_FUNCTION - constexpr mapping(const layout_stride::mapping<_OtherExtents> &other_mapping) + constexpr mapping(const layout_stride::mapping &other_mapping) : padded_stride(padded_stride_type::init_padding( other_mapping, std::integral_constant{})), - exts(other_mapping.extents()) {} + exts(other_mapping.extents()) { + MDSPAN_IMPL_PRECONDITION(detail::check_extents_representability(exts)); + MDSPAN_IMPL_PRECONDITION( + detail::check_extents_and_right_padding_representability( + exts, padded_stride.value(0))); + } /** * Converting constructor from `layout_right_padded::mapping`. @@ -673,22 +884,26 @@ public: * `padding_value == OtherPaddingStride`. */ MDSPAN_TEMPLATE_REQUIRES( - class _Mapping, - /* requires */ (detail::is_layout_right_padded_mapping<_Mapping>::value + class Mapping, + /* requires */ (detail::is_layout_right_padded_mapping::value &&std::is_constructible_v< - extents_type, typename _Mapping::extents_type>)) + extents_type, typename Mapping::extents_type>)) MDSPAN_CONDITIONAL_EXPLICIT((extents_type::rank() > 1 && (padding_value == dynamic_extent || - _Mapping::padding_value == dynamic_extent))) + Mapping::padding_value == dynamic_extent))) MDSPAN_INLINE_FUNCTION - constexpr mapping(const _Mapping &other_mapping) + constexpr mapping(const Mapping &other_mapping) : padded_stride(padded_stride_type::init_padding( other_mapping, std::integral_constant{})), exts(other_mapping.extents()) { static_assert(padding_value == dynamic_extent || - _Mapping::padding_value == dynamic_extent || - padding_value == _Mapping::padding_value); + Mapping::padding_value == dynamic_extent || + padding_value == Mapping::padding_value); + MDSPAN_IMPL_PRECONDITION(detail::check_extents_representability(exts)); + MDSPAN_IMPL_PRECONDITION( + detail::check_extents_and_right_padding_representability( + exts, padded_stride.value(0))); } /** @@ -699,19 +914,24 @@ public: * OtherExtents>` is `true`. */ MDSPAN_TEMPLATE_REQUIRES( - class _Mapping, - /* requires */ (detail::is_layout_left_padded_mapping<_Mapping>::value + class Mapping, + /* requires */ (detail::is_layout_left_padded_mapping::value &&extents_type::rank() <= 1 && std::is_constructible_v)) + typename Mapping::extents_type>)) MDSPAN_CONDITIONAL_EXPLICIT( - (!std::is_convertible_v)) + (!std::is_convertible_v)) MDSPAN_INLINE_FUNCTION - constexpr mapping(const _Mapping &other_mapping) noexcept + constexpr mapping(const Mapping &other_mapping) noexcept : padded_stride(padded_stride_type::init_padding( static_cast(other_mapping.extents()), other_mapping.extents().extent(extent_to_pad_idx))), - exts(other_mapping.extents()) {} + exts(other_mapping.extents()) { + MDSPAN_IMPL_PRECONDITION(detail::check_extents_representability(exts)); + MDSPAN_IMPL_PRECONDITION( + detail::check_extents_and_right_padding_representability( + exts, padded_stride.value(0))); + } MDSPAN_INLINE_FUNCTION constexpr const extents_type & extents() const noexcept { @@ -745,11 +965,11 @@ public: } else if constexpr (extents_type::rank() == 1) { return exts.extent(0); } else { - index_type value = 1; + index_type value = padded_stride.value(0); for (rank_type r = 0; r < extent_to_pad_idx; ++r) { value *= exts.extent(r); } - return value * padded_stride.value(0); + return value == 0 ? 0 : value + exts.extent(extent_to_pad_idx) - padded_stride.value(0); } } @@ -762,13 +982,13 @@ public: * - (is_nothrow_constructible_v && ...) is true. */ MDSPAN_TEMPLATE_REQUIRES( - class... _Indices, - /* requires */ (sizeof...(_Indices) == extents_type::rank() && + class... Indices, + /* requires */ (sizeof...(Indices) == extents_type::rank() && (::MDSPAN_IMPL_STANDARD_NAMESPACE::detail:: - are_valid_indices()))) + are_valid_indices()))) MDSPAN_INLINE_FUNCTION constexpr size_t - operator()(_Indices... idxs) const noexcept { - return compute_offset(std::index_sequence_for<_Indices...>{}, idxs...); + operator()(Indices... idxs) const noexcept { + return compute_offset(std::index_sequence_for{}, idxs...); } MDSPAN_INLINE_FUNCTION static constexpr bool is_always_unique() noexcept { @@ -819,11 +1039,11 @@ public: * Extents>`. However, this makes `padding_value` non-deducible. */ MDSPAN_TEMPLATE_REQUIRES( - class _Mapping, - /* requires */ (detail::is_layout_right_padded_mapping<_Mapping>::value && - (_Mapping::extents_type::rank() == extents_type::rank()))) + class Mapping, + /* requires */ (detail::is_layout_right_padded_mapping::value && + (Mapping::extents_type::rank() == extents_type::rank()))) MDSPAN_INLINE_FUNCTION friend constexpr bool - operator==(const mapping &left, const _Mapping &right) noexcept { + operator==(const mapping &left, const Mapping &right) noexcept { // Workaround for some compilers not short-circuiting properly with // compile-time checks i.e. we can't access stride(_padding_stride_idx) of a // rank 0 mapping @@ -843,11 +1063,11 @@ public: * `OtherExtents::rank() == extents_type::rank()`. */ MDSPAN_TEMPLATE_REQUIRES( - class _Mapping, - /* requires */ (detail::is_layout_right_padded_mapping<_Mapping>::value && - (_Mapping::extents_type::rank() == extents_type::rank()))) + class Mapping, + /* requires */ (detail::is_layout_right_padded_mapping::value && + (Mapping::extents_type::rank() == extents_type::rank()))) MDSPAN_INLINE_FUNCTION friend constexpr bool - operator!=(const mapping &left, const _Mapping &right) noexcept { + operator!=(const mapping &left, const Mapping &right) noexcept { return !(left == right); } #endif diff --git a/ext/mdspan/include/experimental/__p2642_bits/layout_padded_fwd.hpp b/ext/mdspan/include/experimental/__p2642_bits/layout_padded_fwd.hpp index 3f141ff..481b1d5 100644 --- a/ext/mdspan/include/experimental/__p2642_bits/layout_padded_fwd.hpp +++ b/ext/mdspan/include/experimental/__p2642_bits/layout_padded_fwd.hpp @@ -24,110 +24,110 @@ namespace MDSPAN_IMPL_PROPOSED_NAMESPACE { template struct layout_left_padded { - template + template class mapping; }; template struct layout_right_padded { - template + template class mapping; }; namespace detail { // The layout_padded_constants structs are only useful if rank > 1, otherwise they may wrap -template +template struct layout_padded_constants; -template -struct layout_padded_constants, _ExtentsType> +template +struct layout_padded_constants, ExtentsType> { - using rank_type = typename _ExtentsType::rank_type; + using rank_type = typename ExtentsType::rank_type; static constexpr rank_type padded_stride_idx = 1; static constexpr rank_type extent_to_pad_idx = 0; }; -template -struct layout_padded_constants, _ExtentsType> +template +struct layout_padded_constants, ExtentsType> { - using rank_type = typename _ExtentsType::rank_type; - static constexpr rank_type padded_stride_idx = _ExtentsType::rank() - 2; - static constexpr rank_type extent_to_pad_idx = _ExtentsType::rank() - 1; + using rank_type = typename ExtentsType::rank_type; + static constexpr rank_type padded_stride_idx = ExtentsType::rank() - 2; + static constexpr rank_type extent_to_pad_idx = ExtentsType::rank() - 1; }; -template +template struct is_layout_left_padded : std::false_type {}; -template -struct is_layout_left_padded> : std::true_type {}; +template +struct is_layout_left_padded> : std::true_type {}; -template +template struct is_layout_left_padded_mapping : std::false_type {}; -template -struct is_layout_left_padded_mapping<_Mapping, - std::enable_if_t::template mapping>::value>> +template +struct is_layout_left_padded_mapping::template mapping>::value>> : std::true_type {}; -template +template struct is_layout_right_padded : std::false_type {}; -template -struct is_layout_right_padded> : std::true_type {}; +template +struct is_layout_right_padded> : std::true_type {}; -template +template struct is_layout_right_padded_mapping : std::false_type {}; -template -struct is_layout_right_padded_mapping<_Mapping, - std::enable_if_t::template mapping>::value>> +template +struct is_layout_right_padded_mapping::template mapping>::value>> : std::true_type {}; -template +template MDSPAN_INLINE_FUNCTION constexpr void check_padded_layout_converting_constructor_mandates(MDSPAN_IMPL_STANDARD_NAMESPACE::detail::with_rank<0>) {} -template +template MDSPAN_INLINE_FUNCTION constexpr void check_padded_layout_converting_constructor_mandates(MDSPAN_IMPL_STANDARD_NAMESPACE::detail::with_rank<1>) {} -template +template MDSPAN_INLINE_FUNCTION constexpr void check_padded_layout_converting_constructor_mandates(MDSPAN_IMPL_STANDARD_NAMESPACE::detail::with_rank) { - using extents_type = typename _PaddedLayoutMappingType::extents_type; - constexpr auto padding_value = _PaddedLayoutMappingType::padding_value; - constexpr auto idx = layout_padded_constants::extent_to_pad_idx; + using extents_type = typename PaddedLayoutMappingType::extents_type; + constexpr auto padding_value = PaddedLayoutMappingType::padding_value; + constexpr auto idx = layout_padded_constants::extent_to_pad_idx; constexpr auto statically_determinable = - (_LayoutExtentsType::static_extent(idx) != dynamic_extent) && + (LayoutExtentsType::static_extent(idx) != dynamic_extent) && (extents_type::static_extent(idx) != dynamic_extent) && (padding_value != dynamic_extent); static_assert(!statically_determinable || (padding_value == 0 - ? _LayoutExtentsType::static_extent(idx) == 0 - : _LayoutExtentsType::static_extent(idx) % padding_value == 0), + ? LayoutExtentsType::static_extent(idx) == 0 + : LayoutExtentsType::static_extent(idx) % padding_value == 0), ""); } -template +template MDSPAN_INLINE_FUNCTION constexpr void check_padded_layout_converting_constructor_preconditions(MDSPAN_IMPL_STANDARD_NAMESPACE::detail::with_rank<0>, - const _OtherMapping&) {} -template + const OtherMapping&) {} +template MDSPAN_INLINE_FUNCTION constexpr void check_padded_layout_converting_constructor_preconditions(MDSPAN_IMPL_STANDARD_NAMESPACE::detail::with_rank<1>, - const _OtherMapping&) {} -template + const OtherMapping&) {} +template MDSPAN_INLINE_FUNCTION constexpr void check_padded_layout_converting_constructor_preconditions(MDSPAN_IMPL_STANDARD_NAMESPACE::detail::with_rank, - const _OtherMapping &other_mapping) { + const OtherMapping &other_mapping) { constexpr auto padded_stride_idx = - layout_padded_constants::padded_stride_idx; - constexpr auto extent_to_pad_idx = layout_padded_constants::extent_to_pad_idx; + layout_padded_constants::padded_stride_idx; + constexpr auto extent_to_pad_idx = layout_padded_constants::extent_to_pad_idx; MDSPAN_IMPL_PRECONDITION(other_mapping.stride(padded_stride_idx) == other_mapping.extents().extent(extent_to_pad_idx)); } -- cgit v1.2.3