llvm-mirror/tools/bugpoint/ListReducer.h

//===- ListReducer.h - Trim down list while retaining property --*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This class is to be used as a base class for operations that want to zero in
// on a subset of the input which still causes the bug we are tracking.
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_TOOLS_BUGPOINT_LISTREDUCER_H
#define LLVM_TOOLS_BUGPOINT_LISTREDUCER_H

#include "llvm/Support/Error.h"
#include "llvm/Support/raw_ostream.h"
#include <algorithm>
#include <cstdlib>
#include <random>
#include <vector>

namespace llvm {

extern bool BugpointIsInterrupted;

template <typename ElTy> struct ListReducer {
  enum TestResult {
    NoFailure,  // No failure of the predicate was detected
    KeepSuffix, // The suffix alone satisfies the predicate
    KeepPrefix  // The prefix alone satisfies the predicate
  };

  virtual ~ListReducer() {}

  /// This virtual function should be overriden by subclasses to implement the
  /// test desired.  The testcase is only required to test to see if the Kept
  /// list still satisfies the property, but if it is going to check the prefix
  /// anyway, it can.
  virtual Expected<TestResult> doTest(std::vector<ElTy> &Prefix,
                                      std::vector<ElTy> &Kept) = 0;

  /// This function attempts to reduce the length of the specified list while
  /// still maintaining the "test" property.  This is the core of the "work"
  /// that bugpoint does.
  Expected<bool> reduceList(std::vector<ElTy> &TheList) {
    std::vector<ElTy> empty;
    std::mt19937 randomness(0x6e5ea738);  // Seed the random number generator
    Expected<TestResult> Result = doTest(TheList, empty);
    if (Error E = Result.takeError())
      return std::move(E);
    switch (*Result) {
    case KeepPrefix:
      if (TheList.size() == 1) // we are done, it's the base case and it fails
        return true;
      else
        break; // there's definitely an error, but we need to narrow it down

    case KeepSuffix:
      // cannot be reached!
      llvm_unreachable("bugpoint ListReducer internal error: "
                       "selected empty set.");

    case NoFailure:
      return false; // there is no failure with the full set of passes/funcs!
    }

    // Maximal number of allowed splitting iterations,
    // before the elements are randomly shuffled.
    const unsigned MaxIterationsWithoutProgress = 3;

    // Maximal number of allowed single-element trim iterations. We add a
    // threshold here as single-element reductions may otherwise take a
    // very long time to complete.
    const unsigned MaxTrimIterationsWithoutBackJump = 3;
    bool ShufflingEnabled = true;

  Backjump:
    unsigned MidTop = TheList.size();
    unsigned MaxIterations = MaxIterationsWithoutProgress;
    unsigned NumOfIterationsWithoutProgress = 0;
    while (MidTop > 1) { // Binary split reduction loop
      // Halt if the user presses ctrl-c.
      if (BugpointIsInterrupted) {
        errs() << "\n\n*** Reduction Interrupted, cleaning up...\n\n";
        return true;
      }

      // If the loop doesn't make satisfying progress, try shuffling.
      // The purpose of shuffling is to avoid the heavy tails of the
      // distribution (improving the speed of convergence).
      if (ShufflingEnabled && NumOfIterationsWithoutProgress > MaxIterations) {
        std::vector<ElTy> ShuffledList(TheList);
        std::shuffle(ShuffledList.begin(), ShuffledList.end(), randomness);
        errs() << "\n\n*** Testing shuffled set...\n\n";
        // Check that random shuffle doesn't lose the bug
        Expected<TestResult> Result = doTest(ShuffledList, empty);
        // TODO: Previously, this error was ignored and we treated it as if
        // shuffling hid the bug. This should really either be consumeError if
        // that behaviour was sensible, or we should propagate the error.
        assert(!Result.takeError() && "Shuffling caused internal error?");

        if (*Result == KeepPrefix) {
          // If the bug is still here, use the shuffled list.
          TheList.swap(ShuffledList);
          MidTop = TheList.size();
          // Must increase the shuffling treshold to avoid the small
          // probability of infinite looping without making progress.
          MaxIterations += 2;
          errs() << "\n\n*** Shuffling does not hide the bug...\n\n";
        } else {
          ShufflingEnabled = false; // Disable shuffling further on
          errs() << "\n\n*** Shuffling hides the bug...\n\n";
        }
        NumOfIterationsWithoutProgress = 0;
      }

      unsigned Mid = MidTop / 2;
      std::vector<ElTy> Prefix(TheList.begin(), TheList.begin() + Mid);
      std::vector<ElTy> Suffix(TheList.begin() + Mid, TheList.end());

      Expected<TestResult> Result = doTest(Prefix, Suffix);
      if (Error E = Result.takeError())
        return std::move(E);
      switch (*Result) {
      case KeepSuffix:
        // The property still holds.  We can just drop the prefix elements, and
        // shorten the list to the "kept" elements.
        TheList.swap(Suffix);
        MidTop = TheList.size();
        // Reset progress treshold and progress counter
        MaxIterations = MaxIterationsWithoutProgress;
        NumOfIterationsWithoutProgress = 0;
        break;
      case KeepPrefix:
        // The predicate still holds, shorten the list to the prefix elements.
        TheList.swap(Prefix);
        MidTop = TheList.size();
        // Reset progress treshold and progress counter
        MaxIterations = MaxIterationsWithoutProgress;
        NumOfIterationsWithoutProgress = 0;
        break;
      case NoFailure:
        // Otherwise the property doesn't hold.  Some of the elements we removed
        // must be necessary to maintain the property.
        MidTop = Mid;
        NumOfIterationsWithoutProgress++;
        break;
      }
    }

    // Probability of backjumping from the trimming loop back to the binary
    // split reduction loop.
    const int BackjumpProbability = 10;

    // Okay, we trimmed as much off the top and the bottom of the list as we
    // could.  If there is more than two elements in the list, try deleting
    // interior elements and testing that.
    //
    if (TheList.size() > 2) {
      bool Changed = true;
      std::vector<ElTy> EmptyList;
      unsigned TrimIterations = 0;
      while (Changed) { // Trimming loop.
        Changed = false;

        // If the binary split reduction loop made an unfortunate sequence of
        // splits, the trimming loop might be left off with a huge number of
        // remaining elements (large search space). Backjumping out of that
        // search space and attempting a different split can significantly
        // improve the convergence speed.
        if (std::rand() % 100 < BackjumpProbability)
          goto Backjump;

        for (unsigned i = 1; i < TheList.size() - 1; ++i) {
          // Check interior elts
          if (BugpointIsInterrupted) {
            errs() << "\n\n*** Reduction Interrupted, cleaning up...\n\n";
            return true;
          }

          std::vector<ElTy> TestList(TheList);
          TestList.erase(TestList.begin() + i);

          Expected<TestResult> Result = doTest(EmptyList, TestList);
          if (Error E = Result.takeError())
            return std::move(E);
          if (*Result == KeepSuffix) {
            // We can trim down the list!
            TheList.swap(TestList);
            --i; // Don't skip an element of the list
            Changed = true;
          }
        }
        if (TrimIterations >= MaxTrimIterationsWithoutBackJump)
          break;
        TrimIterations++;
      }
    }

    return true; // there are some failure and we've narrowed them down
  }
};

} // End llvm namespace

#endif