Skip to content

Commit

Permalink
remove random buggy identifier names in tests and change _MDSPAN_DEBU…
Browse files Browse the repository at this point in the history 
…G -> MDSPAN_DEBUG
  • Loading branch information
@nmm0
nmm0 committed Feb 13, 2025
1 parent 4497d86 commit c16c6d1
Show file tree
Hide file tree
Showing 6 changed files with 72 additions and 72 deletions.
14 changes: 7 additions & 7 deletions include/experimental/__p0009_bits/extents.hpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -294,7 +294,7 @@ struct maybe_static_array {
m_dyn_vals[dyn_map_t::get(r)] = values[r];
}
// Precondition check
#ifdef _MDSPAN_DEBUG
#ifdef MDSPAN_DEBUG
else {
assert(values[r] == static_cast<TDynamic>(static_val));
}
Expand All @@ -309,7 +309,7 @@ struct maybe_static_array {
constexpr maybe_static_array(const std::array<T, N> &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++) {
Expand All @@ -318,7 +318,7 @@ struct maybe_static_array {
m_dyn_vals[dyn_map_t::get(r)] = static_cast<TDynamic>(vals[r]);
}
// Precondition check
#ifdef _MDSPAN_DEBUG
#ifdef MDSPAN_DEBUG
else {
assert(static_cast<TDynamic>(vals[r]) ==
static_cast<TDynamic>(static_val));
Expand All @@ -334,15 +334,15 @@ struct maybe_static_array {
MDSPAN_INLINE_FUNCTION
constexpr maybe_static_array(const std::span<T, N> &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++) {
TStatic static_val = static_vals_t::get(r);
if (static_val == dyn_tag) {
m_dyn_vals[dyn_map_t::get(r)] = static_cast<TDynamic>(vals[r]);
}
#ifdef _MDSPAN_DEBUG
#ifdef MDSPAN_DEBUG
else {
assert(static_cast<TDynamic>(vals[r]) ==
static_cast<TDynamic>(static_val));
Expand Down Expand Up @@ -622,7 +622,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<ExtentsIndexType>(user_index) >= 0);
#endif
}
Expand All @@ -643,7 +643,7 @@ 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<ExtentsIndexType>(user_index) < current_extent);
#endif
}
Expand Down
76 changes: 38 additions & 38 deletions tests/test_extents.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -46,13 +46,13 @@ struct TestExtents<
size_t* result = allocate_array<size_t>(2);

dispatch([=] _MDSPAN_HOST_DEVICE () {
extents_type _exts(DynamicSizes...);
extents_type exts(DynamicSizes...);
// Silencing an unused warning in nvc++ the condition will never be true
size_t dyn_val = _exts.rank()>0?static_cast<size_t>(_exts.extent(0)):1;
result[0] = dyn_val > 1e9 ? dyn_val : _exts.rank();
result[1] = _exts.rank_dynamic();
// Some compilers warn about unused _exts since the functions are all static constexpr
(void) _exts;
size_t dyn_val = exts.rank()>0?static_cast<size_t>(exts.extent(0)):1;
result[0] = dyn_val > 1e9 ? dyn_val : exts.rank();
result[1] = exts.rank_dynamic();
// Some compilers warn about unused exts since the functions are all static constexpr
(void) exts;
});
EXPECT_EQ(result[0], static_sizes.size());
EXPECT_EQ(result[1], dyn_sizes.size());
Expand All @@ -64,14 +64,14 @@ struct TestExtents<
size_t* result = allocate_array<size_t>(extents_type::rank());

dispatch([=] _MDSPAN_HOST_DEVICE () {
extents_type _exts(DynamicSizes...);
for(size_t r=0; r<_exts.rank(); r++) {
extents_type exts(DynamicSizes...);
for(size_t r=0; r<exts.rank(); r++) {
// Silencing an unused warning in nvc++ the condition will never be true
size_t dyn_val = static_cast<size_t>(_exts.extent(r));
result[r] = dyn_val > 1e9 ? dyn_val : _exts.static_extent(r);
size_t dyn_val = static_cast<size_t>(exts.extent(r));
result[r] = dyn_val > 1e9 ? dyn_val : exts.static_extent(r);
}
// Some compilers warn about unused _exts since the functions are all static constexpr
(void) _exts;
// Some compilers warn about unused exts since the functions are all static constexpr
(void) exts;
});
for(size_t r=0; r<extents_type::rank(); r++) {
EXPECT_EQ(result[r], static_sizes[r]);
Expand All @@ -84,11 +84,11 @@ struct TestExtents<
size_t* result = allocate_array<size_t>(extents_type::rank());

dispatch([=] _MDSPAN_HOST_DEVICE () {
extents_type _exts(DynamicSizes...);
for(size_t r=0; r<_exts.rank(); r++ )
result[r] = _exts.extent(r);
// Some compilers warn about unused _exts since the functions are all static constexpr
(void) _exts;
extents_type exts(DynamicSizes...);
for(size_t r=0; r<exts.rank(); r++ )
result[r] = exts.extent(r);
// Some compilers warn about unused exts since the functions are all static constexpr
(void) exts;
});
int dyn_count = 0;
for(size_t r=0; r<extents_type::rank(); r++) {
Expand All @@ -102,18 +102,18 @@ struct TestExtents<
};

template <size_t... Ds>
using _sizes = std::integer_sequence<size_t, Ds...>;
using sizes = std::integer_sequence<size_t, Ds...>;
template <size_t... Ds>
using _exts = Kokkos::extents<size_t,Ds...>;
using exts = Kokkos::extents<size_t,Ds...>;

using extents_test_types =
::testing::Types<
std::tuple<_exts<10>, _sizes<>>,
std::tuple<_exts<Kokkos::dynamic_extent>, _sizes<10>>,
std::tuple<_exts<10, 3>, _sizes<>>,
std::tuple<_exts<Kokkos::dynamic_extent, 3>, _sizes<10>>,
std::tuple<_exts<10, Kokkos::dynamic_extent>, _sizes<3>>,
std::tuple<_exts<Kokkos::dynamic_extent, Kokkos::dynamic_extent>, _sizes<10, 3>>
std::tuple<exts<10>, sizes<>>,
std::tuple<exts<Kokkos::dynamic_extent>, sizes<10>>,
std::tuple<exts<10, 3>, sizes<>>,
std::tuple<exts<Kokkos::dynamic_extent, 3>, sizes<10>>,
std::tuple<exts<10, Kokkos::dynamic_extent>, sizes<3>>,
std::tuple<exts<Kokkos::dynamic_extent, Kokkos::dynamic_extent>, sizes<10, 3>>
>;

TYPED_TEST_SUITE(TestExtents, extents_test_types);
Expand Down Expand Up @@ -159,7 +159,7 @@ TYPED_TEST(TestExtents, copy_assign) {
// Only types can be part of the gtest type iteration
// so i need this wrapper to wrap around true/false values
template<bool Val1, bool Val2>
struct _BoolPairDeducer {
struct BoolPairDeducer {
static constexpr bool val1 = Val1;
static constexpr bool val2 = Val2;
};
Expand All @@ -172,7 +172,7 @@ struct TestExtentsCompatCtors<std::tuple<
std::integer_sequence<size_t, DynamicSizes...>,
Kokkos::extents<size_t,Extents2...>,
std::integer_sequence<size_t, DynamicSizes2...>,
_BoolPairDeducer<ImplicitExts1ToExts2,ImplicitExts2ToExts1>
BoolPairDeducer<ImplicitExts1ToExts2,ImplicitExts2ToExts1>
>> : public ::testing::Test {
using extents_type1 = Kokkos::extents<size_t,Extents...>;
using extents_type2 = Kokkos::extents<size_t,Extents2...>;
Expand Down Expand Up @@ -232,19 +232,19 @@ struct TestExtentsCompatCtors<std::tuple<

using compatible_extents_test_types =
::testing::Types<
std::tuple<_exts<Kokkos::dynamic_extent>, _sizes<5>, _exts<5>, _sizes<>, _BoolPairDeducer<false,true>>,
std::tuple<_exts<5>, _sizes<>, _exts<Kokkos::dynamic_extent>, _sizes<5>, _BoolPairDeducer<true,false>>,
std::tuple<exts<Kokkos::dynamic_extent>, sizes<5>, exts<5>, sizes<>, BoolPairDeducer<false,true>>,
std::tuple<exts<5>, sizes<>, exts<Kokkos::dynamic_extent>, sizes<5>, BoolPairDeducer<true,false>>,
//--------------------
std::tuple<_exts<Kokkos::dynamic_extent, 10>, _sizes<5>, _exts<5, Kokkos::dynamic_extent>, _sizes<10>, _BoolPairDeducer<false, false>>,
std::tuple<_exts<Kokkos::dynamic_extent, Kokkos::dynamic_extent>, _sizes<5, 10>, _exts<5, Kokkos::dynamic_extent>, _sizes<10>, _BoolPairDeducer<false, true>>,
std::tuple<_exts<Kokkos::dynamic_extent, Kokkos::dynamic_extent>, _sizes<5, 10>, _exts<Kokkos::dynamic_extent, 10>, _sizes<5>, _BoolPairDeducer<false, true>>,
std::tuple<_exts<Kokkos::dynamic_extent, Kokkos::dynamic_extent>, _sizes<5, 10>, _exts<5, 10>, _sizes<>, _BoolPairDeducer<false, true>>,
std::tuple<_exts<5, 10>, _sizes<>, _exts<5, Kokkos::dynamic_extent>, _sizes<10>, _BoolPairDeducer<true, false>>,
std::tuple<_exts<5, 10>, _sizes<>, _exts<Kokkos::dynamic_extent, 10>, _sizes<5>, _BoolPairDeducer<true, false>>,
std::tuple<exts<Kokkos::dynamic_extent, 10>, sizes<5>, exts<5, Kokkos::dynamic_extent>, sizes<10>, BoolPairDeducer<false, false>>,
std::tuple<exts<Kokkos::dynamic_extent, Kokkos::dynamic_extent>, sizes<5, 10>, exts<5, Kokkos::dynamic_extent>, sizes<10>, BoolPairDeducer<false, true>>,
std::tuple<exts<Kokkos::dynamic_extent, Kokkos::dynamic_extent>, sizes<5, 10>, exts<Kokkos::dynamic_extent, 10>, sizes<5>, BoolPairDeducer<false, true>>,
std::tuple<exts<Kokkos::dynamic_extent, Kokkos::dynamic_extent>, sizes<5, 10>, exts<5, 10>, sizes<>, BoolPairDeducer<false, true>>,
std::tuple<exts<5, 10>, sizes<>, exts<5, Kokkos::dynamic_extent>, sizes<10>, BoolPairDeducer<true, false>>,
std::tuple<exts<5, 10>, sizes<>, exts<Kokkos::dynamic_extent, 10>, sizes<5>, BoolPairDeducer<true, false>>,
//--------------------
std::tuple<_exts<Kokkos::dynamic_extent, Kokkos::dynamic_extent, 15>, _sizes<5, 10>, _exts<5, Kokkos::dynamic_extent, 15>, _sizes<10>, _BoolPairDeducer<false, true>>,
std::tuple<_exts<5, 10, 15>, _sizes<>, _exts<5, Kokkos::dynamic_extent, 15>, _sizes<10>, _BoolPairDeducer<true, false>>,
std::tuple<_exts<5, 10, 15>, _sizes<>, _exts<Kokkos::dynamic_extent, Kokkos::dynamic_extent, Kokkos::dynamic_extent>, _sizes<5, 10, 15>, _BoolPairDeducer<true, false>>
std::tuple<exts<Kokkos::dynamic_extent, Kokkos::dynamic_extent, 15>, sizes<5, 10>, exts<5, Kokkos::dynamic_extent, 15>, sizes<10>, BoolPairDeducer<false, true>>,
std::tuple<exts<5, 10, 15>, sizes<>, exts<5, Kokkos::dynamic_extent, 15>, sizes<10>, BoolPairDeducer<true, false>>,
std::tuple<exts<5, 10, 15>, sizes<>, exts<Kokkos::dynamic_extent, Kokkos::dynamic_extent, Kokkos::dynamic_extent>, sizes<5, 10, 15>, BoolPairDeducer<true, false>>
>;

TYPED_TEST_SUITE(TestExtentsCompatCtors, compatible_extents_test_types);
Expand Down
26 changes: 13 additions & 13 deletions tests/test_layout_ctors.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -97,25 +97,25 @@ using test_right_type_compatible = std::tuple<
typename Kokkos::layout_right::template mapping<E2>, S2
>;
template <size_t... Ds>
using _sizes = std::integer_sequence<size_t, Ds...>;
using sizes = std::integer_sequence<size_t, Ds...>;
template <size_t... Ds>
using _exts = Kokkos::extents<size_t,Ds...>;
using exts = Kokkos::extents<size_t,Ds...>;

template <template <class, class, class, class> class _test_case_type>
template <template <class, class, class, class> class test_case_type>
using compatible_layout_test_types =
::testing::Types<
_test_case_type<_exts<dyn>, _sizes<10>, _exts<10>, _sizes<>>,
test_case_type<exts<dyn>, sizes<10>, exts<10>, sizes<>>,
//--------------------
_test_case_type<_exts<dyn, 10>, _sizes<5>, _exts<5, dyn>, _sizes<10>>,
_test_case_type<_exts<dyn, dyn>, _sizes<5, 10>, _exts<5, dyn>, _sizes<10>>,
_test_case_type<_exts<dyn, dyn>, _sizes<5, 10>, _exts<dyn, 10>, _sizes<5>>,
_test_case_type<_exts<dyn, dyn>, _sizes<5, 10>, _exts<5, 10>, _sizes<>>,
_test_case_type<_exts<5, 10>, _sizes<>, _exts<5, dyn>, _sizes<10>>,
_test_case_type<_exts<5, 10>, _sizes<>, _exts<dyn, 10>, _sizes<5>>,
test_case_type<exts<dyn, 10>, sizes<5>, exts<5, dyn>, sizes<10>>,
test_case_type<exts<dyn, dyn>, sizes<5, 10>, exts<5, dyn>, sizes<10>>,
test_case_type<exts<dyn, dyn>, sizes<5, 10>, exts<dyn, 10>, sizes<5>>,
test_case_type<exts<dyn, dyn>, sizes<5, 10>, exts<5, 10>, sizes<>>,
test_case_type<exts<5, 10>, sizes<>, exts<5, dyn>, sizes<10>>,
test_case_type<exts<5, 10>, sizes<>, exts<dyn, 10>, sizes<5>>,
//--------------------
_test_case_type<_exts<dyn, dyn, 15>, _sizes<5, 10>, _exts<5, dyn, 15>, _sizes<10>>,
_test_case_type<_exts<5, 10, 15>, _sizes<>, _exts<5, dyn, 15>, _sizes<10>>,
_test_case_type<_exts<5, 10, 15>, _sizes<>, _exts<dyn, dyn, dyn>, _sizes<5, 10, 15>>
test_case_type<exts<dyn, dyn, 15>, sizes<5, 10>, exts<5, dyn, 15>, sizes<10>>,
test_case_type<exts<5, 10, 15>, sizes<>, exts<5, dyn, 15>, sizes<10>>,
test_case_type<exts<5, 10, 15>, sizes<>, exts<dyn, dyn, dyn>, sizes<5, 10, 15>>
>;

using left_compatible_test_types = compatible_layout_test_types<test_left_type_compatible>;
Expand Down
2 changes: 1 addition & 1 deletion tests/test_layout_padded_left.cpp
View file
Original file line number Diff line number Diff line change
@@ -1,5 +1,5 @@
#define MDSPAN_INTERNAL_TEST
#define _MDSPAN_DEBUG
#define MDSPAN_DEBUG
#include <cassert>

#include <mdspan/mdspan.hpp>
Expand Down
2 changes: 1 addition & 1 deletion tests/test_layout_padded_right.cpp
View file
Original file line number Diff line number Diff line change
@@ -1,5 +1,5 @@
#define MDSPAN_INTERNAL_TEST
#define _MDSPAN_DEBUG
#define MDSPAN_DEBUG
#include <cassert>

#include <mdspan/mdspan.hpp>
Expand Down
24 changes: 12 additions & 12 deletions tests/test_layout_stride.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -33,9 +33,9 @@ struct TestLayoutStride<std::tuple<
};

template <size_t... Extents>
using _exts = Kokkos::extents<size_t,Extents...>;
using exts = Kokkos::extents<size_t,Extents...>;
template <size_t... Vals>
using _ints = std::integer_sequence<size_t, Vals...>;
using ints = std::integer_sequence<size_t, Vals...>;
template <class E, class DSz, class SStr, class DStr>
using layout_stride_case_t =
std::tuple<E, DSz, SStr, DStr>;
Expand All @@ -45,9 +45,9 @@ using extents_3dyn5_t = Kokkos::extents<size_t,3, dyn, 5>;
using extents_ddd_t = Kokkos::extents<size_t,dyn, dyn, dyn>;
using zero_stride_maps =
::testing::Types<
layout_stride_case_t<extents_345_t, _ints<>, _ints<dyn, dyn, dyn>, _ints<0, 0, 0>>,
layout_stride_case_t<extents_3dyn5_t, _ints<4>, _ints<dyn, dyn, dyn>, _ints<0, 0, 0>>,
layout_stride_case_t<extents_ddd_t, _ints<3, 4, 5>, _ints<dyn, dyn, dyn>, _ints<0, 0, 0>>
layout_stride_case_t<extents_345_t, ints<>, ints<dyn, dyn, dyn>, ints<0, 0, 0>>,
layout_stride_case_t<extents_3dyn5_t, ints<4>, ints<dyn, dyn, dyn>, ints<0, 0, 0>>,
layout_stride_case_t<extents_ddd_t, ints<3, 4, 5>, ints<dyn, dyn, dyn>, ints<0, 0, 0>>
>;

template <class T>
Expand Down Expand Up @@ -130,17 +130,17 @@ using test_stride_equality = std::tuple<
Equal
>;
template <size_t... Ds>
using _sizes = std::integer_sequence<size_t, Ds...>;
using sizes = std::integer_sequence<size_t, Ds...>;
template <size_t... Ds>
using _exts = Kokkos::extents<size_t,Ds...>;
using exts = Kokkos::extents<size_t,Ds...>;

template <template <class, class, class, class, class> class _test_case_type>
template <template <class, class, class, class, class> class test_case_type>
using equality_test_types =
::testing::Types<
_test_case_type<_exts<16, 32>, _sizes<1, 16>, _exts<16, 32>, _sizes<1, 16>, std:: true_type>,
_test_case_type<_exts<16, 32>, _sizes<1, 16>, _exts<16, 32>, _sizes<1, 17>, std::false_type>,
_test_case_type<_exts<16, 32>, _sizes<1, 16>, _exts<16, 64>, _sizes<1, 16>, std::false_type>,
_test_case_type<_exts<16, 32>, _sizes<1, 16>, _exts<16, 64>, _sizes<1, 17>, std::false_type>
test_case_type<exts<16, 32>, sizes<1, 16>, exts<16, 32>, sizes<1, 16>, std:: true_type>,
test_case_type<exts<16, 32>, sizes<1, 16>, exts<16, 32>, sizes<1, 17>, std::false_type>,
test_case_type<exts<16, 32>, sizes<1, 16>, exts<16, 64>, sizes<1, 16>, std::false_type>,
test_case_type<exts<16, 32>, sizes<1, 16>, exts<16, 64>, sizes<1, 17>, std::false_type>
>;

using layout_stride_equality_test_types = equality_test_types<test_stride_equality>;
Expand Down

0 comments on commit c16c6d1

Please sign in to comment.