ddc/tests/parallel_copy.cpp at 77f9f3722caf7287d4c583e1df7c30a8518faa5c · CExA-project/ddc · GitHub

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
// Copyright (C) The DDC development team, see COPYRIGHT.md file
//
// SPDX-License-Identifier: MIT

#include <ddc/ddc.hpp>

#include <gtest/gtest.h>

#include <Kokkos_Core.hpp>
#include <Kokkos_StdAlgorithms.hpp>

#include "ddc/kokkos_allocator.hpp"

inline namespace anonymous_namespace_workaround_parallel_copy_cpp {

using DElem0D = ddc::DiscreteElement<>;
using DVect0D = ddc::DiscreteVector<>;
using DDom0D = ddc::DiscreteDomain<>;

template <class Datatype>
using Chunk0D = ddc::Chunk<Datatype, DDom0D>;
template <class Datatype>
using ChunkSpan0D = ddc::ChunkSpan<Datatype, DDom0D>;


struct DDimX
{
};
using DElemX = ddc::DiscreteElement<DDimX>;
using DVectX = ddc::DiscreteVector<DDimX>;
using DDomX = ddc::DiscreteDomain<DDimX>;

template <class Datatype>
using ChunkX = ddc::Chunk<Datatype, DDomX>;


struct DDimY
{
};
using DElemY = ddc::DiscreteElement<DDimY>;
using DVectY = ddc::DiscreteVector<DDimY>;
using DDomY = ddc::DiscreteDomain<DDimY>;

template <class Datatype>
using ChunkY = ddc::Chunk<Datatype, DDomY>;


struct DDimZ
{
};
using DElemZ = ddc::DiscreteElement<DDimZ>;
using DVectZ = ddc::DiscreteVector<DDimZ>;
using DDomZ = ddc::DiscreteDomain<DDimZ>;


using DElemXY = ddc::DiscreteElement<DDimX, DDimY>;
using DVectXY = ddc::DiscreteVector<DDimX, DDimY>;
using DDomXY = ddc::DiscreteDomain<DDimX, DDimY>;

template <class Datatype>
using ChunkXY = ddc::Chunk<Datatype, DDomXY>;


using DElemYX = ddc::DiscreteElement<DDimY, DDimX>;
using DVectYX = ddc::DiscreteVector<DDimY, DDimX>;
using DDomYX = ddc::DiscreteDomain<DDimY, DDimX>;

template <class Datatype>
using ChunkYX = ddc::Chunk<Datatype, DDomYX>;


using DElemXYZ = ddc::DiscreteElement<DDimX, DDimY, DDimZ>;
using DVectXYZ = ddc::DiscreteVector<DDimX, DDimY, DDimZ>;
using DDomXYZ = ddc::DiscreteDomain<DDimX, DDimY, DDimZ>;

DElem0D constexpr lbound_0d {};
DVect0D constexpr nelems_0d {};
DDom0D constexpr dom_0d(lbound_0d, nelems_0d);

DElemX constexpr lbound_x = ddc::init_trivial_half_bounded_space<DDimX>();
DVectX constexpr nelems_x(3);
DDomX constexpr dom_x(lbound_x, nelems_x);

DElemY constexpr lbound_y = ddc::init_trivial_half_bounded_space<DDimY>();
DVectY constexpr nelems_y(12);

DElemZ constexpr lbound_z = ddc::init_trivial_half_bounded_space<DDimZ>();
DVectZ constexpr nelems_z(5);

DElemXY constexpr lbound_x_y(lbound_x, lbound_y);
DVectXY constexpr nelems_x_y(nelems_x, nelems_y);
DDomXY constexpr dom_x_y(lbound_x_y, nelems_x_y);

DElemXYZ constexpr lbound_x_y_z(lbound_x, lbound_y, lbound_z);
DVectXYZ constexpr nelems_x_y_z(nelems_x, nelems_y, nelems_z);
DDomXYZ constexpr dom_x_y_z(lbound_x_y_z, nelems_x_y_z);

} // namespace anonymous_namespace_workaround_parallel_copy_cpp

TEST(ParallelCopy, BroadcastScalar2XY)
{
    Kokkos::DefaultExecutionSpace const exec_space;

    Kokkos::View<int*> const storage(Kokkos::view_alloc("storage", exec_space), dom_x_y.size());
    ddc::ChunkSpan const
            chunk_x_y(Kokkos::View<int**>(storage.data(), nelems_x, nelems_y), dom_x_y);
    ddc::parallel_fill(exec_space, chunk_x_y, 0);

    ddc::Chunk chunk(dom_0d, ddc::DeviceAllocator<int>());
    ddc::parallel_fill(exec_space, chunk, 1);

    ddc::parallel_copy(exec_space, chunk_x_y, chunk);

    EXPECT_EQ(Kokkos::Experimental::count(exec_space, storage, 1), dom_x_y.size());
}

TEST(ParallelCopy, BroadcastX2XY)
{
    Kokkos::DefaultExecutionSpace const exec_space;

    Kokkos::View<int*> const storage(Kokkos::view_alloc("storage", exec_space), dom_x_y.size());
    ddc::ChunkSpan const
            chunk_x_y(Kokkos::View<int**>(storage.data(), nelems_x, nelems_y), dom_x_y);
    ddc::parallel_fill(exec_space, chunk_x_y, 0);

    ddc::Chunk chunk_x(dom_x, ddc::DeviceAllocator<int>());
    ddc::parallel_fill(exec_space, chunk_x, 1);

    ddc::parallel_copy(exec_space, chunk_x_y, chunk_x);

    EXPECT_EQ(Kokkos::Experimental::count(exec_space, storage, 1), dom_x_y.size());
}

TEST(ParallelCopy, TransposeXY2XY)
{
    Kokkos::DefaultExecutionSpace const exec_space;

    Kokkos::View<int*> const storage(Kokkos::view_alloc("storage", exec_space), dom_x_y.size());
    ddc::ChunkSpan const
            chunk_x_y_out(Kokkos::View<int**>(storage.data(), nelems_x, nelems_y), dom_x_y);
    ddc::parallel_fill(exec_space, chunk_x_y_out, 0);

    ddc::Chunk chunk_x_y_in(dom_x_y, ddc::DeviceAllocator<int>());
    ddc::parallel_fill(exec_space, chunk_x_y_in, 1);

    ddc::parallel_copy(exec_space, chunk_x_y_out, chunk_x_y_in);

    EXPECT_EQ(Kokkos::Experimental::count(exec_space, storage, 1), dom_x_y.size());
}

TEST(ParallelCopy, BroadcastAndTransposeYX2XYZ)
{
    Kokkos::DefaultExecutionSpace const exec_space;

    Kokkos::View<int*> const storage(Kokkos::view_alloc("storage", exec_space), dom_x_y_z.size());
    ddc::ChunkSpan const chunk_x_y_z(
            Kokkos::View<int***>(storage.data(), nelems_x, nelems_y, nelems_z),
            dom_x_y_z);
    ddc::parallel_fill(exec_space, chunk_x_y_z, 0);

    DDomYX const dom_y_x(dom_x_y);
    ddc::Chunk chunk_y_x(dom_y_x, ddc::DeviceAllocator<int>());
    ddc::parallel_fill(exec_space, chunk_y_x, 1);

    ddc::parallel_copy(exec_space, chunk_x_y_z, chunk_y_x);

    EXPECT_EQ(Kokkos::Experimental::count(exec_space, storage, 1), dom_x_y_z.size());
}