1 //===- ListReducer.h - Trim down list while retaining property --*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This class is to be used as a base class for operations that want to zero in
11 // on a subset of the input which still causes the bug we are tracking.
13 //===----------------------------------------------------------------------===//
15 #ifndef LLVM_TOOLS_BUGPOINT_LISTREDUCER_H
16 #define LLVM_TOOLS_BUGPOINT_LISTREDUCER_H
18 #include "llvm/Support/ErrorHandling.h"
19 #include "llvm/Support/raw_ostream.h"
26 extern bool BugpointIsInterrupted;
28 template<typename ElTy>
31 NoFailure, // No failure of the predicate was detected
32 KeepSuffix, // The suffix alone satisfies the predicate
33 KeepPrefix, // The prefix alone satisfies the predicate
34 InternalError // Encountered an error trying to run the predicate
37 virtual ~ListReducer() {}
39 // doTest - This virtual function should be overriden by subclasses to
40 // implement the test desired. The testcase is only required to test to see
41 // if the Kept list still satisfies the property, but if it is going to check
42 // the prefix anyway, it can.
44 virtual TestResult doTest(std::vector<ElTy> &Prefix,
45 std::vector<ElTy> &Kept,
46 std::string &Error) = 0;
48 // reduceList - This function attempts to reduce the length of the specified
49 // list while still maintaining the "test" property. This is the core of the
50 // "work" that bugpoint does.
52 bool reduceList(std::vector<ElTy> &TheList, std::string &Error) {
53 std::vector<ElTy> empty;
54 std::srand(0x6e5ea738); // Seed the random number generator
55 switch (doTest(TheList, empty, Error)) {
57 if (TheList.size() == 1) // we are done, it's the base case and it fails
60 break; // there's definitely an error, but we need to narrow it down
64 llvm_unreachable("bugpoint ListReducer internal error: "
65 "selected empty set.");
68 return false; // there is no failure with the full set of passes/funcs!
71 assert(!Error.empty());
75 // Maximal number of allowed splitting iterations,
76 // before the elements are randomly shuffled.
77 const unsigned MaxIterationsWithoutProgress = 3;
79 // Maximal number of allowed single-element trim iterations. We add a
80 // threshhold here as single-element reductions may otherwise take a
81 // very long time to complete.
82 const unsigned MaxTrimIterationsWithoutBackJump = 3;
83 bool ShufflingEnabled = true;
86 unsigned MidTop = TheList.size();
87 unsigned MaxIterations = MaxIterationsWithoutProgress;
88 unsigned NumOfIterationsWithoutProgress = 0;
89 while (MidTop > 1) { // Binary split reduction loop
90 // Halt if the user presses ctrl-c.
91 if (BugpointIsInterrupted) {
92 errs() << "\n\n*** Reduction Interrupted, cleaning up...\n\n";
96 // If the loop doesn't make satisfying progress, try shuffling.
97 // The purpose of shuffling is to avoid the heavy tails of the
98 // distribution (improving the speed of convergence).
99 if (ShufflingEnabled &&
100 NumOfIterationsWithoutProgress > MaxIterations) {
101 std::vector<ElTy> ShuffledList(TheList);
102 std::random_shuffle(ShuffledList.begin(), ShuffledList.end());
103 errs() << "\n\n*** Testing shuffled set...\n\n";
104 // Check that random shuffle doesn't loose the bug
105 if (doTest(ShuffledList, empty, Error) == KeepPrefix) {
106 // If the bug is still here, use the shuffled list.
107 TheList.swap(ShuffledList);
108 MidTop = TheList.size();
109 // Must increase the shuffling treshold to avoid the small
110 // probability of inifinite looping without making progress.
112 errs() << "\n\n*** Shuffling does not hide the bug...\n\n";
114 ShufflingEnabled = false; // Disable shuffling further on
115 errs() << "\n\n*** Shuffling hides the bug...\n\n";
117 NumOfIterationsWithoutProgress = 0;
120 unsigned Mid = MidTop / 2;
121 std::vector<ElTy> Prefix(TheList.begin(), TheList.begin()+Mid);
122 std::vector<ElTy> Suffix(TheList.begin()+Mid, TheList.end());
124 switch (doTest(Prefix, Suffix, Error)) {
126 // The property still holds. We can just drop the prefix elements, and
127 // shorten the list to the "kept" elements.
128 TheList.swap(Suffix);
129 MidTop = TheList.size();
130 // Reset progress treshold and progress counter
131 MaxIterations = MaxIterationsWithoutProgress;
132 NumOfIterationsWithoutProgress = 0;
135 // The predicate still holds, shorten the list to the prefix elements.
136 TheList.swap(Prefix);
137 MidTop = TheList.size();
138 // Reset progress treshold and progress counter
139 MaxIterations = MaxIterationsWithoutProgress;
140 NumOfIterationsWithoutProgress = 0;
143 // Otherwise the property doesn't hold. Some of the elements we removed
144 // must be necessary to maintain the property.
146 NumOfIterationsWithoutProgress++;
149 return true; // Error was set by doTest.
151 assert(Error.empty() && "doTest did not return InternalError for error");
154 // Probability of backjumping from the trimming loop back to the binary
155 // split reduction loop.
156 const int BackjumpProbability = 10;
158 // Okay, we trimmed as much off the top and the bottom of the list as we
159 // could. If there is more than two elements in the list, try deleting
160 // interior elements and testing that.
162 if (TheList.size() > 2) {
164 std::vector<ElTy> EmptyList;
165 unsigned TrimIterations = 0;
166 while (Changed) { // Trimming loop.
169 // If the binary split reduction loop made an unfortunate sequence of
170 // splits, the trimming loop might be left off with a huge number of
171 // remaining elements (large search space). Backjumping out of that
172 // search space and attempting a different split can significantly
173 // improve the convergence speed.
174 if (std::rand() % 100 < BackjumpProbability)
177 for (unsigned i = 1; i < TheList.size()-1; ++i) { // Check interior elts
178 if (BugpointIsInterrupted) {
179 errs() << "\n\n*** Reduction Interrupted, cleaning up...\n\n";
183 std::vector<ElTy> TestList(TheList);
184 TestList.erase(TestList.begin()+i);
186 if (doTest(EmptyList, TestList, Error) == KeepSuffix) {
187 // We can trim down the list!
188 TheList.swap(TestList);
189 --i; // Don't skip an element of the list
195 if (TrimIterations >= MaxTrimIterationsWithoutBackJump)
201 return true; // there are some failure and we've narrowed them down
205 } // End llvm namespace