Skip to content

Commit 1a7554e

Browse files
author
zxy.monado
committed
test(base): cover MPI type variants
1 parent d4262a8 commit 1a7554e

3 files changed

Lines changed: 202 additions & 1 deletion

File tree

‎source/source_base/test_parallel/CMakeLists.txt‎

Lines changed: 11 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -40,6 +40,17 @@ AddTest(
4040
SOURCES test_para_gemm.cpp
4141
)
4242

43+
AddTest(
44+
TARGET MODULE_BASE_parallel_device
45+
LIBS MPI::MPI_CXX base device parameter
46+
SOURCES parallel_device_test.cpp ../test/mpi_test_main.cpp
47+
)
48+
49+
add_test(NAME MODULE_BASE_parallel_device_parallel
50+
COMMAND mpirun -np 4 ./MODULE_BASE_parallel_device
51+
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
52+
)
53+
4354
AddTest(
4455
TARGET MODULE_BASE_math_chebyshev_mpi
4556
LIBS MPI::MPI_CXX parameter base device container

‎source/source_base/test_parallel/parallel_device_test.cpp‎

Lines changed: 133 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,133 @@
1+
#ifdef __MPI
2+
#include "source_base/parallel_device.h"
3+
4+
#include "source_base/communication_domain.h"
5+
6+
#include "gtest/gtest.h"
7+
#include <complex>
8+
#include <vector>
9+
10+
namespace
11+
{
12+
13+
template <typename T>
14+
void exercise_cpu_point()
15+
{
16+
const int count = 2;
17+
T values[count] = {static_cast<T>(1), static_cast<T>(2)};
18+
T temporary[count] = {};
19+
Parallel_Common::object_cpu_point<T, base_device::DEVICE_CPU> point;
20+
21+
EXPECT_EQ(point.get_buffer(values, count), values);
22+
EXPECT_EQ(point.get(values, count), values);
23+
EXPECT_EQ(point.get_buffer(values, count, temporary), values);
24+
EXPECT_EQ(point.get(values, count, temporary), values);
25+
point.sync_h2d(values, temporary, count);
26+
point.sync_d2h(temporary, values, count);
27+
point.del(values);
28+
}
29+
30+
template <typename T>
31+
void exercise_gpu_staging_stubs()
32+
{
33+
const int count = 2;
34+
T values[count] = {static_cast<T>(1), static_cast<T>(2)};
35+
T temporary[count] = {};
36+
Parallel_Common::object_cpu_point<T, base_device::DEVICE_GPU> point;
37+
38+
EXPECT_EQ(point.get_buffer(values, count, temporary), temporary);
39+
EXPECT_EQ(point.get(values, count, temporary), temporary);
40+
point.sync_h2d(values, temporary, count);
41+
point.sync_d2h(temporary, values, count);
42+
point.del(temporary);
43+
44+
T* allocated = point.get_buffer(values, count);
45+
EXPECT_NE(allocated, nullptr);
46+
point.del(allocated);
47+
}
48+
49+
template <typename T>
50+
void exercise_mpi_wrappers(const ModuleBase::CommunicationDomain& domain)
51+
{
52+
MPI_Comm communicator = domain.communicator();
53+
const int rank = domain.rank();
54+
const int size = domain.size();
55+
const int count = 2;
56+
57+
T sent[count] = {static_cast<T>(rank + 1), static_cast<T>(rank + 2)};
58+
T received[count] = {};
59+
MPI_Status status;
60+
MPI_Request request;
61+
Parallel_Common::send_dev<T, base_device::DEVICE_CPU>(sent, count, MPI_PROC_NULL, 0, communicator);
62+
Parallel_Common::isend_dev<T, base_device::DEVICE_CPU>(sent,
63+
count,
64+
MPI_PROC_NULL,
65+
0,
66+
communicator,
67+
&request,
68+
nullptr);
69+
Parallel_Common::recv_dev<T, base_device::DEVICE_CPU>(received, count, MPI_PROC_NULL, 0, communicator, &status);
70+
71+
T broadcast[count] = {};
72+
if (rank == 0)
73+
{
74+
broadcast[0] = static_cast<T>(3);
75+
broadcast[1] = static_cast<T>(5);
76+
}
77+
Parallel_Common::bcast_dev<T, base_device::DEVICE_CPU>(broadcast, count, communicator, 0);
78+
EXPECT_EQ(broadcast[0], static_cast<T>(3));
79+
EXPECT_EQ(broadcast[1], static_cast<T>(5));
80+
81+
T reduced[count] = {static_cast<T>(rank + 1), static_cast<T>(2 * (rank + 1))};
82+
Parallel_Common::reduce_dev<T, base_device::DEVICE_CPU>(reduced, count, communicator);
83+
const T sum = static_cast<T>(size * (size + 1) / 2);
84+
EXPECT_EQ(reduced[0], sum);
85+
EXPECT_EQ(reduced[1], static_cast<T>(2) * sum);
86+
87+
const T gathered_value = static_cast<T>(rank + 1);
88+
std::vector<T> gathered(size);
89+
std::vector<int> receive_counts(size, 1);
90+
std::vector<int> displacements(size);
91+
for (int index = 0; index < size; ++index)
92+
{
93+
displacements[index] = index;
94+
}
95+
Parallel_Common::gatherv_dev<T, base_device::DEVICE_CPU>(&gathered_value,
96+
1,
97+
gathered.data(),
98+
receive_counts.data(),
99+
displacements.data(),
100+
communicator);
101+
for (int index = 0; index < size; ++index)
102+
{
103+
EXPECT_EQ(gathered[index], static_cast<T>(index + 1));
104+
}
105+
}
106+
107+
TEST(ParallelDevice, CoversCpuPointSpecializations)
108+
{
109+
exercise_cpu_point<float>();
110+
exercise_cpu_point<double>();
111+
exercise_cpu_point<std::complex<float>>();
112+
exercise_cpu_point<std::complex<double>>();
113+
}
114+
115+
TEST(ParallelDevice, CoversGpuStagingWithoutAccelerator)
116+
{
117+
exercise_gpu_staging_stubs<float>();
118+
exercise_gpu_staging_stubs<double>();
119+
exercise_gpu_staging_stubs<std::complex<float>>();
120+
exercise_gpu_staging_stubs<std::complex<double>>();
121+
}
122+
123+
TEST(ParallelDevice, CoversMpiTypeOverloads)
124+
{
125+
const ModuleBase::CommunicationDomain domain = ModuleBase::world_communication_domain();
126+
exercise_mpi_wrappers<float>(domain);
127+
exercise_mpi_wrappers<double>(domain);
128+
exercise_mpi_wrappers<std::complex<float>>(domain);
129+
exercise_mpi_wrappers<std::complex<double>>(domain);
130+
}
131+
132+
} // namespace
133+
#endif

‎source/source_base/test_parallel/parallel_reduce_test.cpp‎

Lines changed: 58 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,8 @@
11
#ifdef __MPI
22
#include "source_base/parallel_reduce.h"
33

4-
#include "source_base/parallel_global.h"
54
#include "mpi.h"
5+
#include "source_base/parallel_global.h"
66

77
#include "gtest/gtest.h"
88
#include <assert.h>
@@ -217,6 +217,39 @@ TEST_F(ParaReduce, ReduceComplexAll)
217217
delete[] rand_array;
218218
}
219219

220+
TEST_F(ParaReduce, ReduceAdditionalTypesAll)
221+
{
222+
const float float_local = static_cast<float>(my_rank + 1);
223+
const float float_expected = static_cast<float>(nproc * (nproc + 1) / 2);
224+
float float_scalar = float_local;
225+
float float_array[2] = {float_local, 2.0F * float_local};
226+
Parallel_Reduce::reduce_all(float_scalar);
227+
Parallel_Reduce::reduce_all(float_array, 2);
228+
EXPECT_FLOAT_EQ(float_scalar, float_expected);
229+
EXPECT_FLOAT_EQ(float_array[0], float_expected);
230+
EXPECT_FLOAT_EQ(float_array[1], 2.0F * float_expected);
231+
232+
const std::complex<float> complex_local(float_local, -float_local);
233+
const std::complex<float> complex_expected(float_expected, -float_expected);
234+
std::complex<float> complex_scalar = complex_local;
235+
std::complex<float> complex_array[2] = {complex_local, 2.0F * complex_local};
236+
Parallel_Reduce::reduce_all(complex_scalar);
237+
Parallel_Reduce::reduce_all(complex_array, 2);
238+
EXPECT_EQ(complex_scalar, complex_expected);
239+
EXPECT_EQ(complex_array[0], complex_expected);
240+
EXPECT_EQ(complex_array[1], 2.0F * complex_expected);
241+
242+
const long long long_local = static_cast<long long>(my_rank + 1);
243+
const long long long_expected = static_cast<long long>(nproc * (nproc + 1) / 2);
244+
long long long_scalar = long_local;
245+
long long long_array[2] = {long_local, 2 * long_local};
246+
Parallel_Reduce::reduce_all(long_scalar);
247+
Parallel_Reduce::reduce_all(long_array, 2);
248+
EXPECT_EQ(long_scalar, long_expected);
249+
EXPECT_EQ(long_array[0], long_expected);
250+
EXPECT_EQ(long_array[1], 2 * long_expected);
251+
}
252+
220253
TEST_F(ParaReduce, GatherIntAll)
221254
{
222255
std::default_random_engine e(time(NULL) * (my_rank + 1));
@@ -264,6 +297,13 @@ TEST_F(ParaReduce, GatherDoubleAll)
264297
/// my_rank,i,array[i],min_number,max_number);
265298
}
266299
delete[] array;
300+
301+
float min_float = static_cast<float>(my_rank);
302+
float max_float = min_float;
303+
Parallel_Reduce::reduce_min(min_float);
304+
Parallel_Reduce::reduce_max(max_float);
305+
EXPECT_FLOAT_EQ(min_float, 0.0F);
306+
EXPECT_FLOAT_EQ(max_float, static_cast<float>(nproc - 1));
267307
}
268308

269309
TEST_F(ParaReduce, ReduceDoubleDiag)
@@ -409,6 +449,23 @@ TEST_F(ParaReduce, ReduceDoublePool)
409449
/// global_sum_first, global_sum_second);
410450
EXPECT_NEAR(global_sum_first, global_sum_second, 1e-14);
411451

452+
const float float_local = static_cast<float>(mpiContext.rank_in_pool + 1);
453+
const float float_expected = static_cast<float>(mpiContext.nproc_in_pool * (mpiContext.nproc_in_pool + 1) / 2);
454+
float float_scalar = float_local;
455+
Parallel_Reduce::reduce_pool(float_scalar);
456+
EXPECT_FLOAT_EQ(float_scalar, float_expected);
457+
458+
int int_array[2] = {mpiContext.rank_in_pool + 1, 2 * (mpiContext.rank_in_pool + 1)};
459+
Parallel_Reduce::reduce_pool(int_array, 2);
460+
EXPECT_EQ(int_array[0], static_cast<int>(float_expected));
461+
EXPECT_EQ(int_array[1], 2 * static_cast<int>(float_expected));
462+
463+
std::complex<float> complex_array[2]
464+
= {std::complex<float>(float_local, -float_local), std::complex<float>(2.0F * float_local, float_local)};
465+
Parallel_Reduce::reduce_pool(complex_array, 2);
466+
EXPECT_EQ(complex_array[0], std::complex<float>(float_expected, -float_expected));
467+
EXPECT_EQ(complex_array[1], std::complex<float>(2.0F * float_expected, float_expected));
468+
412469
delete[] rand_array;
413470
MPI_Comm_free(&POOL_WORLD);
414471
}

0 commit comments

Comments
 (0)