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
|
//===- llvm/unittest/Support/ParallelTest.cpp -----------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
///
/// \file
/// Parallel.h unit tests.
///
//===----------------------------------------------------------------------===//
#include "llvm/Support/Parallel.h"
#include "gtest/gtest.h"
#include <array>
#include <random>
uint32_t array[1024 * 1024];
using namespace llvm;
// Tests below are hanging up on mingw. Investigating.
#if !defined(__MINGW32__)
TEST(Parallel, sort) {
std::mt19937 randEngine;
std::uniform_int_distribution<uint32_t> dist;
for (auto &i : array)
i = dist(randEngine);
parallelSort(std::begin(array), std::end(array));
ASSERT_TRUE(llvm::is_sorted(array));
}
TEST(Parallel, parallel_for) {
// We need to test the case with a TaskSize > 1. We are white-box testing
// here. The TaskSize is calculated as (End - Begin) / 1024 at the time of
// writing.
uint32_t range[2050];
std::fill(range, range + 2050, 1);
parallelForEachN(0, 2049, [&range](size_t I) { ++range[I]; });
uint32_t expected[2049];
std::fill(expected, expected + 2049, 2);
ASSERT_TRUE(std::equal(range, range + 2049, expected));
// Check that we don't write past the end of the requested range.
ASSERT_EQ(range[2049], 1u);
}
TEST(Parallel, TransformReduce) {
// Sum an empty list, check that it works.
auto identity = [](uint32_t v) { return v; };
uint32_t sum = parallelTransformReduce(ArrayRef<uint32_t>(), 0U,
std::plus<uint32_t>(), identity);
EXPECT_EQ(sum, 0U);
// Sum the lengths of these strings in parallel.
const char *strs[] = {"a", "ab", "abc", "abcd", "abcde", "abcdef"};
size_t lenSum =
parallelTransformReduce(strs, static_cast<size_t>(0), std::plus<size_t>(),
[](const char *s) { return strlen(s); });
EXPECT_EQ(lenSum, static_cast<size_t>(21));
// Check that we handle non-divisible task sizes as above.
uint32_t range[2050];
std::fill(std::begin(range), std::end(range), 1);
sum = parallelTransformReduce(range, 0U, std::plus<uint32_t>(), identity);
EXPECT_EQ(sum, 2050U);
std::fill(std::begin(range), std::end(range), 2);
sum = parallelTransformReduce(range, 0U, std::plus<uint32_t>(), identity);
EXPECT_EQ(sum, 4100U);
// Avoid one large task.
uint32_t range2[3060];
std::fill(std::begin(range2), std::end(range2), 1);
sum = parallelTransformReduce(range2, 0U, std::plus<uint32_t>(), identity);
EXPECT_EQ(sum, 3060U);
}
TEST(Parallel, ForEachError) {
int nums[] = {1, 2, 3, 4, 5, 6};
Error e = parallelForEachError(nums, [](int v) -> Error {
if ((v & 1) == 0)
return createStringError(std::errc::invalid_argument, "asdf");
return Error::success();
});
EXPECT_TRUE(e.isA<ErrorList>());
std::string errText = toString(std::move(e));
EXPECT_EQ(errText, std::string("asdf\nasdf\nasdf"));
}
#endif
|
