422 lines
17 KiB
C++
422 lines
17 KiB
C++
//@HEADER
|
|
// ************************************************************************
|
|
//
|
|
// Kokkos v. 4.0
|
|
// Copyright (2022) National Technology & Engineering
|
|
// Solutions of Sandia, LLC (NTESS).
|
|
//
|
|
// Under the terms of Contract DE-NA0003525 with NTESS,
|
|
// the U.S. Government retains certain rights in this software.
|
|
//
|
|
// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://kokkos.org/LICENSE for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//@HEADER
|
|
|
|
#include <Kokkos_Core.hpp>
|
|
|
|
namespace {
|
|
|
|
struct TestReducerCTADS {
|
|
using execspace = TEST_EXECSPACE;
|
|
using scalar_type = double;
|
|
using index_type = int;
|
|
using memspace = execspace::memory_space;
|
|
|
|
struct CustomComparator {
|
|
bool operator()(scalar_type, scalar_type) const;
|
|
};
|
|
static CustomComparator comparator;
|
|
|
|
struct TestSum {
|
|
static Kokkos::View<scalar_type, memspace> view;
|
|
static Kokkos::View<scalar_type, memspace,
|
|
Kokkos::MemoryTraits<Kokkos::Unmanaged>>
|
|
unmanaged;
|
|
static Kokkos::Sum<scalar_type, memspace> rt;
|
|
|
|
static_assert(std::is_same_v<decltype(rt), decltype(Kokkos::Sum(view))>);
|
|
static_assert(std::is_same_v<decltype(rt), decltype(Kokkos::Sum(rt))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::Sum(std::move(rt)))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::Sum(unmanaged))>);
|
|
};
|
|
|
|
struct TestProd {
|
|
static Kokkos::View<scalar_type, memspace> view;
|
|
static Kokkos::View<scalar_type, memspace,
|
|
Kokkos::MemoryTraits<Kokkos::Unmanaged>>
|
|
unmanaged;
|
|
static Kokkos::Prod<scalar_type, memspace> rt;
|
|
|
|
static_assert(std::is_same_v<decltype(rt), decltype(Kokkos::Prod(view))>);
|
|
static_assert(std::is_same_v<decltype(rt), decltype(Kokkos::Prod(rt))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::Prod(std::move(rt)))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::Prod(unmanaged))>);
|
|
};
|
|
|
|
struct TestMin {
|
|
static Kokkos::View<scalar_type, memspace> view;
|
|
static Kokkos::View<scalar_type, memspace,
|
|
Kokkos::MemoryTraits<Kokkos::Unmanaged>>
|
|
unmanaged;
|
|
static Kokkos::Min<scalar_type, memspace> rt;
|
|
|
|
static_assert(std::is_same_v<decltype(rt), decltype(Kokkos::Min(view))>);
|
|
static_assert(std::is_same_v<decltype(rt), decltype(Kokkos::Min(rt))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::Min(std::move(rt)))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::Min(unmanaged))>);
|
|
};
|
|
|
|
struct TestMax {
|
|
static Kokkos::View<scalar_type, memspace> view;
|
|
static Kokkos::View<scalar_type, memspace,
|
|
Kokkos::MemoryTraits<Kokkos::Unmanaged>>
|
|
unmanaged;
|
|
static Kokkos::Max<scalar_type, memspace> rt;
|
|
|
|
static_assert(std::is_same_v<decltype(rt), decltype(Kokkos::Max(view))>);
|
|
static_assert(std::is_same_v<decltype(rt), decltype(Kokkos::Max(rt))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::Max(std::move(rt)))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::Max(unmanaged))>);
|
|
};
|
|
|
|
struct TestLAnd {
|
|
static Kokkos::View<scalar_type, memspace> view;
|
|
static Kokkos::View<scalar_type, memspace,
|
|
Kokkos::MemoryTraits<Kokkos::Unmanaged>>
|
|
unmanaged;
|
|
static Kokkos::LAnd<scalar_type, memspace> rt;
|
|
|
|
static_assert(std::is_same_v<decltype(rt), decltype(Kokkos::LAnd(view))>);
|
|
static_assert(std::is_same_v<decltype(rt), decltype(Kokkos::LAnd(rt))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::LAnd(std::move(rt)))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::LAnd(unmanaged))>);
|
|
};
|
|
|
|
struct TestLOr {
|
|
static Kokkos::View<scalar_type, memspace> view;
|
|
static Kokkos::View<scalar_type, memspace,
|
|
Kokkos::MemoryTraits<Kokkos::Unmanaged>>
|
|
unmanaged;
|
|
static Kokkos::LOr<scalar_type, memspace> rt;
|
|
|
|
static_assert(std::is_same_v<decltype(rt), decltype(Kokkos::LOr(view))>);
|
|
static_assert(std::is_same_v<decltype(rt), decltype(Kokkos::LOr(rt))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::LOr(std::move(rt)))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::LOr(unmanaged))>);
|
|
};
|
|
|
|
struct TestBAnd {
|
|
static Kokkos::View<scalar_type, memspace> view;
|
|
static Kokkos::View<scalar_type, memspace,
|
|
Kokkos::MemoryTraits<Kokkos::Unmanaged>>
|
|
unmanaged;
|
|
static Kokkos::BAnd<scalar_type, memspace> rt;
|
|
|
|
static_assert(std::is_same_v<decltype(rt), decltype(Kokkos::BAnd(view))>);
|
|
static_assert(std::is_same_v<decltype(rt), decltype(Kokkos::BAnd(rt))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::BAnd(std::move(rt)))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::BAnd(unmanaged))>);
|
|
};
|
|
|
|
struct TestBOr {
|
|
static Kokkos::View<scalar_type, memspace> view;
|
|
static Kokkos::View<scalar_type, memspace,
|
|
Kokkos::MemoryTraits<Kokkos::Unmanaged>>
|
|
unmanaged;
|
|
static Kokkos::BOr<scalar_type, memspace> rt;
|
|
|
|
static_assert(std::is_same_v<decltype(rt), decltype(Kokkos::BOr(view))>);
|
|
static_assert(std::is_same_v<decltype(rt), decltype(Kokkos::BOr(rt))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::BOr(std::move(rt)))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::BOr(unmanaged))>);
|
|
};
|
|
|
|
struct TestMinLoc {
|
|
static Kokkos::View<Kokkos::ValLocScalar<scalar_type, index_type>, memspace>
|
|
view;
|
|
static Kokkos::View<Kokkos::ValLocScalar<scalar_type, index_type>, memspace,
|
|
Kokkos::MemoryTraits<Kokkos::Unmanaged>>
|
|
unmanaged;
|
|
static Kokkos::MinLoc<scalar_type, index_type, memspace> rt;
|
|
|
|
static_assert(std::is_same_v<decltype(rt), decltype(Kokkos::MinLoc(view))>);
|
|
static_assert(std::is_same_v<decltype(rt), decltype(Kokkos::MinLoc(rt))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::MinLoc(std::move(rt)))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::MinLoc(unmanaged))>);
|
|
};
|
|
|
|
struct TestMaxLoc {
|
|
static Kokkos::View<Kokkos::ValLocScalar<scalar_type, index_type>, memspace>
|
|
view;
|
|
static Kokkos::View<Kokkos::ValLocScalar<scalar_type, index_type>, memspace,
|
|
Kokkos::MemoryTraits<Kokkos::Unmanaged>>
|
|
unmanaged;
|
|
static Kokkos::MaxLoc<scalar_type, index_type, memspace> rt;
|
|
|
|
static_assert(std::is_same_v<decltype(rt), decltype(Kokkos::MaxLoc(view))>);
|
|
static_assert(std::is_same_v<decltype(rt), decltype(Kokkos::MaxLoc(rt))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::MaxLoc(std::move(rt)))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::MaxLoc(unmanaged))>);
|
|
};
|
|
|
|
struct TestMinMax {
|
|
static Kokkos::View<Kokkos::MinMaxScalar<scalar_type>, memspace> view;
|
|
static Kokkos::View<Kokkos::MinMaxScalar<scalar_type>, memspace,
|
|
Kokkos::MemoryTraits<Kokkos::Unmanaged>>
|
|
unmanaged;
|
|
static Kokkos::MinMax<scalar_type, memspace> rt;
|
|
|
|
static_assert(std::is_same_v<decltype(rt), decltype(Kokkos::MinMax(view))>);
|
|
static_assert(std::is_same_v<decltype(rt), decltype(Kokkos::MinMax(rt))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::MinMax(std::move(rt)))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::MinMax(unmanaged))>);
|
|
};
|
|
|
|
struct TestMinMaxLoc {
|
|
static Kokkos::View<Kokkos::MinMaxLocScalar<scalar_type, index_type>,
|
|
memspace>
|
|
view;
|
|
static Kokkos::View<Kokkos::MinMaxLocScalar<scalar_type, index_type>,
|
|
memspace, Kokkos::MemoryTraits<Kokkos::Unmanaged>>
|
|
unmanaged;
|
|
static Kokkos::MinMaxLoc<scalar_type, index_type, memspace> rt;
|
|
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::MinMaxLoc(view))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::MinMaxLoc(rt))>);
|
|
static_assert(std::is_same_v<decltype(rt),
|
|
decltype(Kokkos::MinMaxLoc(std::move(rt)))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::MinMaxLoc(unmanaged))>);
|
|
};
|
|
|
|
struct TestMaxFirstLoc {
|
|
static Kokkos::View<Kokkos::ValLocScalar<scalar_type, index_type>, memspace>
|
|
view;
|
|
static Kokkos::View<Kokkos::ValLocScalar<scalar_type, index_type>, memspace,
|
|
Kokkos::MemoryTraits<Kokkos::Unmanaged>>
|
|
unmanaged;
|
|
static Kokkos::MaxFirstLoc<scalar_type, index_type, memspace> rt;
|
|
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::MaxFirstLoc(view))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::MaxFirstLoc(rt))>);
|
|
static_assert(std::is_same_v<decltype(rt),
|
|
decltype(Kokkos::MaxFirstLoc(std::move(rt)))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::MaxFirstLoc(unmanaged))>);
|
|
};
|
|
|
|
struct TestMaxFirstLocCustomComparator {
|
|
static Kokkos::View<Kokkos::ValLocScalar<scalar_type, index_type>, memspace>
|
|
view;
|
|
static Kokkos::View<Kokkos::ValLocScalar<scalar_type, index_type>, memspace,
|
|
Kokkos::MemoryTraits<Kokkos::Unmanaged>>
|
|
unmanaged;
|
|
static Kokkos::MaxFirstLocCustomComparator<scalar_type, index_type,
|
|
CustomComparator, memspace>
|
|
rt;
|
|
|
|
static_assert(std::is_same_v<decltype(rt),
|
|
decltype(Kokkos::MaxFirstLocCustomComparator(
|
|
view, comparator))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt),
|
|
decltype(Kokkos::MaxFirstLocCustomComparator(rt))>);
|
|
static_assert(std::is_same_v<decltype(rt),
|
|
decltype(Kokkos::MaxFirstLocCustomComparator(
|
|
std::move(rt)))>);
|
|
static_assert(std::is_same_v<decltype(rt),
|
|
decltype(Kokkos::MaxFirstLocCustomComparator(
|
|
unmanaged, comparator))>);
|
|
};
|
|
|
|
struct TestMinFirstLoc {
|
|
static Kokkos::View<Kokkos::ValLocScalar<scalar_type, index_type>, memspace>
|
|
view;
|
|
static Kokkos::View<Kokkos::ValLocScalar<scalar_type, index_type>, memspace,
|
|
Kokkos::MemoryTraits<Kokkos::Unmanaged>>
|
|
unmanaged;
|
|
static Kokkos::MinFirstLoc<scalar_type, index_type, memspace> rt;
|
|
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::MinFirstLoc(view))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::MinFirstLoc(rt))>);
|
|
static_assert(std::is_same_v<decltype(rt),
|
|
decltype(Kokkos::MinFirstLoc(std::move(rt)))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::MinFirstLoc(unmanaged))>);
|
|
};
|
|
|
|
struct TestMinFirstLocCustomComparator {
|
|
static Kokkos::View<Kokkos::ValLocScalar<scalar_type, index_type>, memspace>
|
|
view;
|
|
static Kokkos::View<Kokkos::ValLocScalar<scalar_type, index_type>, memspace,
|
|
Kokkos::MemoryTraits<Kokkos::Unmanaged>>
|
|
unmanaged;
|
|
static Kokkos::MinFirstLocCustomComparator<scalar_type, index_type,
|
|
CustomComparator, memspace>
|
|
rt;
|
|
|
|
static_assert(std::is_same_v<decltype(rt),
|
|
decltype(Kokkos::MinFirstLocCustomComparator(
|
|
view, comparator))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt),
|
|
decltype(Kokkos::MinFirstLocCustomComparator(rt))>);
|
|
static_assert(std::is_same_v<decltype(rt),
|
|
decltype(Kokkos::MinFirstLocCustomComparator(
|
|
std::move(rt)))>);
|
|
static_assert(std::is_same_v<decltype(rt),
|
|
decltype(Kokkos::MinFirstLocCustomComparator(
|
|
unmanaged, comparator))>);
|
|
};
|
|
|
|
struct TestMinMaxFirstLastLoc {
|
|
static Kokkos::View<Kokkos::MinMaxLocScalar<scalar_type, index_type>,
|
|
memspace>
|
|
view;
|
|
static Kokkos::View<Kokkos::MinMaxLocScalar<scalar_type, index_type>,
|
|
memspace, Kokkos::MemoryTraits<Kokkos::Unmanaged>>
|
|
unmanaged;
|
|
static Kokkos::MinMaxFirstLastLoc<scalar_type, index_type, memspace> rt;
|
|
|
|
static_assert(std::is_same_v<decltype(rt),
|
|
decltype(Kokkos::MinMaxFirstLastLoc(view))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::MinMaxFirstLastLoc(rt))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt),
|
|
decltype(Kokkos::MinMaxFirstLastLoc(std::move(rt)))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt),
|
|
decltype(Kokkos::MinMaxFirstLastLoc(unmanaged))>);
|
|
};
|
|
|
|
struct TestMinMaxFirstLastLocCustomComparator {
|
|
static Kokkos::View<Kokkos::MinMaxLocScalar<scalar_type, index_type>,
|
|
memspace>
|
|
view;
|
|
static Kokkos::View<Kokkos::MinMaxLocScalar<scalar_type, index_type>,
|
|
memspace, Kokkos::MemoryTraits<Kokkos::Unmanaged>>
|
|
unmanaged;
|
|
static Kokkos::MinMaxFirstLastLocCustomComparator<
|
|
scalar_type, index_type, CustomComparator, memspace>
|
|
rt;
|
|
|
|
static_assert(
|
|
std::is_same_v<decltype(rt),
|
|
decltype(Kokkos::MinMaxFirstLastLocCustomComparator(
|
|
view, comparator))>);
|
|
static_assert(std::is_same_v<
|
|
decltype(rt),
|
|
decltype(Kokkos::MinMaxFirstLastLocCustomComparator(rt))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt),
|
|
decltype(Kokkos::MinMaxFirstLastLocCustomComparator(
|
|
std::move(rt)))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt),
|
|
decltype(Kokkos::MinMaxFirstLastLocCustomComparator(
|
|
unmanaged, comparator))>);
|
|
};
|
|
|
|
struct TestFirstLoc {
|
|
static Kokkos::View<Kokkos::FirstLocScalar<index_type>, memspace> view;
|
|
static Kokkos::View<Kokkos::FirstLocScalar<index_type>, memspace,
|
|
Kokkos::MemoryTraits<Kokkos::Unmanaged>>
|
|
unmanaged;
|
|
static Kokkos::FirstLoc<index_type, memspace> rt;
|
|
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::FirstLoc(view))>);
|
|
static_assert(std::is_same_v<decltype(rt), decltype(Kokkos::FirstLoc(rt))>);
|
|
static_assert(std::is_same_v<decltype(rt),
|
|
decltype(Kokkos::FirstLoc(std::move(rt)))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::FirstLoc(unmanaged))>);
|
|
};
|
|
|
|
struct TestLastLoc {
|
|
static Kokkos::View<Kokkos::LastLocScalar<index_type>, memspace> view;
|
|
static Kokkos::View<Kokkos::LastLocScalar<index_type>, memspace,
|
|
Kokkos::MemoryTraits<Kokkos::Unmanaged>>
|
|
unmanaged;
|
|
static Kokkos::LastLoc<index_type, memspace> rt;
|
|
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::LastLoc(view))>);
|
|
static_assert(std::is_same_v<decltype(rt), decltype(Kokkos::LastLoc(rt))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::LastLoc(std::move(rt)))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::LastLoc(unmanaged))>);
|
|
};
|
|
|
|
struct TestStdIsPartitioned {
|
|
static Kokkos::View<Kokkos::StdIsPartScalar<index_type>, memspace> view;
|
|
static Kokkos::View<Kokkos::StdIsPartScalar<index_type>, memspace,
|
|
Kokkos::MemoryTraits<Kokkos::Unmanaged>>
|
|
unmanaged;
|
|
static Kokkos::StdIsPartitioned<index_type, memspace> rt;
|
|
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::StdIsPartitioned(view))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::StdIsPartitioned(rt))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt),
|
|
decltype(Kokkos::StdIsPartitioned(std::move(rt)))>);
|
|
static_assert(std::is_same_v<
|
|
decltype(rt), decltype(Kokkos::StdIsPartitioned(unmanaged))>);
|
|
};
|
|
|
|
struct TestStdPartitionPoint {
|
|
static Kokkos::View<Kokkos::StdPartPointScalar<index_type>, memspace> view;
|
|
static Kokkos::View<Kokkos::StdPartPointScalar<index_type>, memspace,
|
|
Kokkos::MemoryTraits<Kokkos::Unmanaged>>
|
|
unmanaged;
|
|
static Kokkos::StdPartitionPoint<index_type, memspace> rt;
|
|
|
|
static_assert(std::is_same_v<decltype(rt),
|
|
decltype(Kokkos::StdPartitionPoint(view))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt), decltype(Kokkos::StdPartitionPoint(rt))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt),
|
|
decltype(Kokkos::StdPartitionPoint(std::move(rt)))>);
|
|
static_assert(
|
|
std::is_same_v<decltype(rt),
|
|
decltype(Kokkos::StdPartitionPoint(unmanaged))>);
|
|
};
|
|
};
|
|
|
|
} // namespace
|