Mercurial > hg > CbC > CbC_llvm

comparison unittests/tools/llvm-exegesis/ClusteringTest.cpp @ 148:63bd29f05246

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
merged
author Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date Wed, 14 Aug 2019 19:46:37 +0900
parents c2174574ed3a
children
comparison
equal deleted inserted replaced
146:3fc4d5c3e21e 148:63bd29f05246
1 //===-- ClusteringTest.cpp --------------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "Clustering.h"
10 #include "BenchmarkResult.h"
11 #include "llvm/Support/Error.h"
12 #include "llvm/Support/raw_ostream.h"
13 #include "gmock/gmock.h"
14 #include "gtest/gtest.h"
15
16 namespace llvm {
17 namespace exegesis {
18
19 namespace {
20
21 using testing::Field;
22 using testing::UnorderedElementsAre;
23 using testing::UnorderedElementsAreArray;
24
25 static const auto HasPoints = [](const std::vector<int> &Indices) {
26 return Field(&InstructionBenchmarkClustering::Cluster::PointIndices,
27 UnorderedElementsAreArray(Indices));
28 };
29
30 TEST(ClusteringTest, Clusters3D) {
31 std::vector<InstructionBenchmark> Points(6);
32
33 // Cluster around (x=0, y=1, z=2): points {0, 3}.
34 Points[0].Measurements = {
35 {"x", 0.01, 0.0}, {"y", 1.02, 0.0}, {"z", 1.98, 0.0}};
36 Points[3].Measurements = {
37 {"x", -0.01, 0.0}, {"y", 1.02, 0.0}, {"z", 1.98, 0.0}};
38 // Cluster around (x=1, y=1, z=2): points {1, 4}.
39 Points[1].Measurements = {
40 {"x", 1.01, 0.0}, {"y", 1.02, 0.0}, {"z", 1.98, 0.0}};
41 Points[4].Measurements = {
42 {"x", 0.99, 0.0}, {"y", 1.02, 0.0}, {"z", 1.98, 0.0}};
43 // Cluster around (x=0, y=0, z=0): points {5}, marked as noise.
44 Points[5].Measurements = {
45 {"x", 0.0, 0.0}, {"y", 0.01, 0.0}, {"z", -0.02, 0.0}};
46 // Error cluster: points {2}
47 Points[2].Error = "oops";
48
49 auto Clustering = InstructionBenchmarkClustering::create(
50 Points, InstructionBenchmarkClustering::ModeE::Dbscan, 2, 0.25);
51 ASSERT_TRUE((bool)Clustering);
52 EXPECT_THAT(Clustering.get().getValidClusters(),
53 UnorderedElementsAre(HasPoints({0, 3}), HasPoints({1, 4})));
54 EXPECT_THAT(Clustering.get().getCluster(
55 InstructionBenchmarkClustering::ClusterId::noise()),
56 HasPoints({5}));
57 EXPECT_THAT(Clustering.get().getCluster(
58 InstructionBenchmarkClustering::ClusterId::error()),
59 HasPoints({2}));
60
61 EXPECT_EQ(Clustering.get().getClusterIdForPoint(2),
62 InstructionBenchmarkClustering::ClusterId::error());
63 EXPECT_EQ(Clustering.get().getClusterIdForPoint(5),
64 InstructionBenchmarkClustering::ClusterId::noise());
65 EXPECT_EQ(Clustering.get().getClusterIdForPoint(0),
66 Clustering.get().getClusterIdForPoint(3));
67 EXPECT_EQ(Clustering.get().getClusterIdForPoint(1),
68 Clustering.get().getClusterIdForPoint(4));
69 }
70
71 TEST(ClusteringTest, Clusters3D_InvalidSize) {
72 std::vector<InstructionBenchmark> Points(6);
73 Points[0].Measurements = {
74 {"x", 0.01, 0.0}, {"y", 1.02, 0.0}, {"z", 1.98, 0.0}};
75 Points[1].Measurements = {{"y", 1.02, 0.0}, {"z", 1.98, 0.0}};
76 auto Error =
77 InstructionBenchmarkClustering::create(
78 Points, InstructionBenchmarkClustering::ModeE::Dbscan, 2, 0.25)
79 .takeError();
80 ASSERT_TRUE((bool)Error);
81 consumeError(std::move(Error));
82 }
83
84 TEST(ClusteringTest, Clusters3D_InvalidOrder) {
85 std::vector<InstructionBenchmark> Points(6);
86 Points[0].Measurements = {{"x", 0.01, 0.0}, {"y", 1.02, 0.0}};
87 Points[1].Measurements = {{"y", 1.02, 0.0}, {"x", 1.98, 0.0}};
88 auto Error =
89 InstructionBenchmarkClustering::create(
90 Points, InstructionBenchmarkClustering::ModeE::Dbscan, 2, 0.25)
91 .takeError();
92 ASSERT_TRUE((bool)Error);
93 consumeError(std::move(Error));
94 }
95
96 TEST(ClusteringTest, Ordering) {
97 ASSERT_LT(InstructionBenchmarkClustering::ClusterId::makeValid(1),
98 InstructionBenchmarkClustering::ClusterId::makeValid(2));
99
100 ASSERT_LT(InstructionBenchmarkClustering::ClusterId::makeValid(2),
101 InstructionBenchmarkClustering::ClusterId::noise());
102
103 ASSERT_LT(InstructionBenchmarkClustering::ClusterId::makeValid(2),
104 InstructionBenchmarkClustering::ClusterId::error());
105
106 ASSERT_LT(InstructionBenchmarkClustering::ClusterId::noise(),
107 InstructionBenchmarkClustering::ClusterId::error());
108 }
109
110 TEST(ClusteringTest, Ordering1) {
111 std::vector<InstructionBenchmark> Points(3);
112
113 Points[0].Measurements = {
114 {"x", 0.0, 0.0}};
115 Points[1].Measurements = {
116 {"x", 1.0, 0.0}};
117 Points[2].Measurements = {
118 {"x", 2.0, 0.0}};
119
120 auto Clustering = InstructionBenchmarkClustering::create(
121 Points, InstructionBenchmarkClustering::ModeE::Dbscan, 2, 1.1);
122 ASSERT_TRUE((bool)Clustering);
123 EXPECT_THAT(Clustering.get().getValidClusters(),
124 UnorderedElementsAre(HasPoints({0, 1, 2})));
125 }
126
127 TEST(ClusteringTest, Ordering2) {
128 std::vector<InstructionBenchmark> Points(3);
129
130 Points[0].Measurements = {
131 {"x", 0.0, 0.0}};
132 Points[1].Measurements = {
133 {"x", 2.0, 0.0}};
134 Points[2].Measurements = {
135 {"x", 1.0, 0.0}};
136
137 auto Clustering = InstructionBenchmarkClustering::create(
138 Points, InstructionBenchmarkClustering::ModeE::Dbscan, 2, 1.1);
139 ASSERT_TRUE((bool)Clustering);
140 EXPECT_THAT(Clustering.get().getValidClusters(),
141 UnorderedElementsAre(HasPoints({0, 1, 2})));
142 }
143
144 } // namespace
145 } // namespace exegesis
146 } // namespace llvm