Silence Adams2019 Autoscheduler

src/autoschedulers/adams2019/ASLog.h

@@ -5,6 +5,7 @@
 // libHalide, so (despite the namespace) we are better off not
 // including Halide.h, lest we reference something we won't have available
 
+#include <cassert>
 #include <cstdlib>
 #include <iostream>
 #include <utility>
@@ -28,6 +29,12 @@ class aslog {
  return *this;
  }
 
+ std::ostream &get_ostream() {
+ // It is an error to call this for an aslog() instance that cannot log.
+ assert(logging);
+ return std::cerr;
+ }
+
  static int aslog_level();
 };
 

src/autoschedulers/adams2019/AutoSchedule.cpp

@@ -117,42 +117,45 @@ struct ProgressBar {
  if (!draw_progress_bar) {
  return;
  }
+ auto &os = aslog(ProgressBarLogLevel).get_ostream();
  counter++;
  const int bits = 11;
  if (counter & ((1 << bits) - 1)) {
  return;
  }
  const int pos = (int)(progress * 78);
- aslog(0) << "[";
+ os << "[";
  for (int j = 0; j < 78; j++) {
  if (j < pos) {
- aslog(0) << ".";
+ os << ".";
  } else if (j - 1 < pos) {
- aslog(0) << "/-\\|"[(counter >> bits) % 4];
+ os << "/-\\|"[(counter >> bits) % 4];
  } else {
- aslog(0) << " ";
+ os << " ";
  }
  }
- aslog(0) << "]";
+ os << "]";
  for (int j = 0; j < 80; j++) {
- aslog(0) << "\b";
+ os << "\b";
  }
  }
 
  void clear() {
  if (counter) {
+ auto &os = aslog(ProgressBarLogLevel).get_ostream();
  for (int j = 0; j < 80; j++) {
- aslog(0) << " ";
+ os << " ";
  }
  for (int j = 0; j < 80; j++) {
- aslog(0) << "\b";
+ os << "\b";
  }
  }
  }
 
 private:
  uint32_t counter = 0;
- const bool draw_progress_bar = isatty(2);
+ static constexpr int ProgressBarLogLevel = 1;
+ const bool draw_progress_bar = isatty(2) && aslog::aslog_level() >= ProgressBarLogLevel;
 };
 
 // Get the HL_RANDOM_DROPOUT environment variable. Purpose of this is described above.
@@ -290,10 +293,6 @@ IntrusivePtr<State> optimal_schedule_pass(FunctionDAG &dag,
 
  std::function<void(IntrusivePtr<State> &&)> enqueue_new_children =
  [&](IntrusivePtr<State> &&s) {
- // aslog(0) << "\n** Generated child: ";
- // s->dump();
- // s->calculate_cost(dag, params, nullptr, true);
-
  // Each child should have one more decision made than its parent state.
  internal_assert(s->num_decisions_made == s->parent->num_decisions_made + 1);
 
@@ -338,7 +337,7 @@ IntrusivePtr<State> optimal_schedule_pass(FunctionDAG &dag,
  }
 
  if ((int)pending.size() > beam_size * 10000) {
- aslog(0) << "Warning: Huge number of states generated (" << pending.size() << ").\n";
+ aslog(1) << "*** Warning: Huge number of states generated (" << pending.size() << ").\n";
  }
 
  expanded = 0;
@@ -436,25 +435,26 @@ IntrusivePtr<State> optimal_schedule_pass(FunctionDAG &dag,
  // The user has set HL_CYOS, and wants to navigate the
  // search space manually. Discard everything in the queue
  // except for the user-chosen option.
- aslog(0) << "\n--------------------\n";
- aslog(0) << "Select a schedule:\n";
+ std::cout << "\n--------------------\n";
+ std::cout << "Select a schedule:\n";
  for (int choice_label = (int)q.size() - 1; choice_label >= 0; choice_label--) {
  auto state = q[choice_label];
- aslog(0) << "\n[" << choice_label << "]:\n";
- state->dump();
- state->calculate_cost(dag, params, cost_model, cache->options, memory_limit, true);
+ std::cout << "\n[" << choice_label << "]:\n";
+ state->dump(std::cout);
+ constexpr int verbosity_level = 0; // always
+ state->calculate_cost(dag, params, cost_model, cache->options, memory_limit, verbosity_level);
  }
  cost_model->evaluate_costs();
 
  // Select next partial schedule to expand.
  int selection = -1;
  while (selection < 0 || selection >= (int)q.size()) {
- aslog(0) << "\nEnter selection: ";
+ std::cout << "\nEnter selection: ";
  std::cin >> selection;
  }
 
  auto selected = q[selection];
- selected->dump();
+ selected->dump(std::cout);
  q.clear();
  q.emplace(std::move(selected));
  }
@@ -508,11 +508,16 @@ IntrusivePtr<State> optimal_schedule(FunctionDAG &dag,
 
  tick.clear();
 
- if (aslog::aslog_level() == 0) {
- aslog(0) << "Pass " << i << " of " << num_passes << ", cost: " << pass->cost << ", time (ms): " << milli << "\n";
- } else {
- aslog(0) << "Pass " << i << " result: ";
- pass->dump();
+ switch (aslog::aslog_level()) {
+ case 0:
+ // Silence
+ break;
+ case 1:
+ aslog(1) << "Pass " << i << " of " << num_passes << ", cost: " << pass->cost << ", time (ms): " << milli << "\n";
+ break;
+ default:
+ aslog(2) << "Pass " << i << " result: ";
+ pass->dump(aslog(2).get_ostream());
  }
 
  if (i == 0 || pass->cost < best->cost) {
@@ -522,11 +527,11 @@ IntrusivePtr<State> optimal_schedule(FunctionDAG &dag,
  }
  }
 
- aslog(0) << "Best cost: " << best->cost << "\n";
+ aslog(1) << "Best cost: " << best->cost << "\n";
 
  if (options.cache_blocks) {
- aslog(0) << "Cache (block) hits: " << cache.cache_hits << "\n";
- aslog(0) << "Cache (block) misses: " << cache.cache_misses << "\n";
+ aslog(1) << "Cache (block) hits: " << cache.cache_hits << "\n";
+ aslog(1) << "Cache (block) misses: " << cache.cache_misses << "\n";
  }
 
  return best;
@@ -540,7 +545,7 @@ void generate_schedule(const std::vector<Function> &outputs,
  const Target &target,
  const MachineParams &params,
  AutoSchedulerResults *auto_scheduler_results) {
- aslog(0) << "generate_schedule for target=" << target.to_string() << "\n";
+ aslog(1) << "generate_schedule for target=" << target.to_string() << "\n";
 
  // Start a timer
  HALIDE_TIC;
@@ -554,7 +559,7 @@ void generate_schedule(const std::vector<Function> &outputs,
  if (!seed_str.empty()) {
  seed = atoi(seed_str.c_str());
  }
- aslog(1) << "Dropout seed = " << seed << "\n";
+ aslog(2) << "Dropout seed = " << seed << "\n";
  std::mt19937 rng((uint32_t)seed);
 
  // Get the beam size
@@ -576,8 +581,8 @@ void generate_schedule(const std::vector<Function> &outputs,
 
  // Analyse the Halide algorithm and construct our abstract representation of it
  FunctionDAG dag(outputs, params, target);
- if (aslog::aslog_level() > 0) {
- dag.dump();
+ if (aslog::aslog_level() >= 2) {
+ dag.dump(aslog(2).get_ostream());
  }
 
  // Construct a cost model to use to evaluate states. Currently we
@@ -602,14 +607,14 @@ void generate_schedule(const std::vector<Function> &outputs,
  aslog(1) << "** Optimal schedule:\n";
 
  // Just to get the debugging prints to fire
- optimal->calculate_cost(dag, params, cost_model.get(), cache_options, memory_limit, aslog::aslog_level() > 0);
+ optimal->calculate_cost(dag, params, cost_model.get(), cache_options, memory_limit, /*verbosity_level*/ 1);
 
  // Apply the schedules to the pipeline
  optimal->apply_schedule(dag, params);
 
  // Print out the schedule
- if (aslog::aslog_level() > 0) {
- optimal->dump();
+ if (aslog::aslog_level() >= 2) {
+ optimal->dump(aslog(2).get_ostream());
  }
 
  string schedule_file = get_env_variable("HL_SCHEDULE_FILE");

src/autoschedulers/adams2019/DefaultCostModel.cpp

@@ -232,18 +232,18 @@ float DefaultCostModel::backprop(const Runtime::Buffer<const float> &true_runtim
  *(cost_ptrs(i)) = dst(i);
  if (std::isnan(dst(i))) {
  any_nans = true;
- aslog(0) << "Prediction " << i << " is NaN. True runtime is " << true_runtimes(i) << "\n";
- aslog(0) << "Checking pipeline features for NaNs...\n";
+ aslog(1) << "Prediction " << i << " is NaN. True runtime is " << true_runtimes(i) << "\n";
+ aslog(1) << "Checking pipeline features for NaNs...\n";
  pipeline_feat_queue.for_each_value([&](float f) { if (std::isnan(f)) abort(); });
- aslog(0) << "None found\n";
- aslog(0) << "Checking schedule features for NaNs...\n";
+ aslog(1) << "None found\n";
+ aslog(1) << "Checking schedule features for NaNs...\n";
  schedule_feat_queue.for_each_value([&](float f) { if (std::isnan(f)) abort(); });
- aslog(0) << "None found\n";
- aslog(0) << "Checking network weights for NaNs...\n";
+ aslog(1) << "None found\n";
+ aslog(1) << "Checking network weights for NaNs...\n";
  weights.for_each_buffer([&](const Runtime::Buffer<float> &buf) {
  buf.for_each_value([&](float f) { if (std::isnan(f)) abort(); });
  });
- aslog(0) << "None found\n";
+ aslog(1) << "None found\n";
  }
  internal_assert(true_runtimes(i) > 0);
  }

src/autoschedulers/adams2019/Featurization.h

@@ -99,8 +99,7 @@ struct PipelineFeatures {
  // Each row sums to 1 or 0. Each column sums to 1. f(z, y, x, 4)
  int slice_accesses[(int)AccessType::NumAccessTypes][(int)ScalarType::NumScalarTypes] = {};
 
- template<typename OS>
- void dump(OS &os) const {
+ void dump(std::ostream &os) const {
  for (int i = 0; i < (int)ScalarType::NumScalarTypes; i++) {
  const char *type_names[] = {"Bool", "UInt8", "UInt16", "UInt32", "UInt64", "Float", "Double"};
  // Skip printing for types not used
@@ -157,10 +156,6 @@ struct PipelineFeatures {
  << slice_accesses[3][i] << "\n";
  }
  }
- void dump() const {
- auto os = aslog(0);
- dump(os);
- }
 };
 
 // The schedule-dependent portion of the featurization of a stage
@@ -314,8 +309,7 @@ struct ScheduleFeatures {
  double working_set_at_realization = 0;
  double working_set_at_root = 0;
 
- template<typename OS>
- void dump(OS &os) const {
+ void dump(std::ostream &os) const {
  os << " num_realizations: " << num_realizations << "\n"
  << " num_productions: " << num_productions << "\n"
  << " points_computed_per_realization: " << points_computed_per_realization << "\n"
@@ -356,10 +350,6 @@ struct ScheduleFeatures {
  << " working_set_at_realization: " << working_set_at_realization << "\n"
  << " working_set_at_root: " << working_set_at_root << "\n";
  }
- void dump() const {
- auto os = aslog(0);
- dump(os);
- }
 
  bool equal(const ScheduleFeatures &other) const {
  const size_t n_features = ScheduleFeatures::num_features();

src/autoschedulers/adams2019/FunctionDAG.cpp

@@ -307,42 +307,44 @@ class Featurizer : public IRVisitor {
 
 } // namespace
 
-void LoadJacobian::dump(const char *prefix) const {
+void LoadJacobian::dump(std::ostream &os, const char *prefix) const {
  if (count() > 1) {
- aslog(0) << prefix << count() << " x\n";
+ os << prefix << count() << " x\n";
  }
  for (size_t i = 0; i < producer_storage_dims(); i++) {
- aslog(0) << prefix << " [";
+ os << prefix << " [";
 
  for (size_t j = 0; j < consumer_loop_dims(); j++) {
  const auto &c = (*this)(i, j);
  if (!c.exists) {
- aslog(0) << " _ ";
+ os << " _ ";
  } else if (c.denominator == 1) {
- aslog(0) << " " << c.numerator << " ";
+ os << " " << c.numerator << " ";
  } else {
- aslog(0) << c.numerator << "/" << c.denominator << " ";
+ os << c.numerator << "/" << c.denominator << " ";
  }
  }
- aslog(0) << "]\n";
+ os << "]\n";
  }
- aslog(0) << "\n";
+ os << "\n";
 }
 
 void BoundContents::validate() const {
  for (int i = 0; i < layout->total_size; i++) {
  auto p = data()[i];
  if (p.max() < p.min()) {
- aslog(0) << "Bad bounds object:\n";
+ std::ostringstream err;
+ err << "Bad bounds object:\n";
  for (int j = 0; j < layout->total_size; j++) {
  if (i == j) {
- aslog(0) << "=> ";
+ err << "=> ";
  } else {
- aslog(0) << " ";
+ err << " ";
  }
- aslog(0) << j << ": " << data()[j].min() << ", " << data()[j].max() << "\n";
+ err << j << ": " << data()[j].min() << ", " << data()[j].max() << "\n";
  }
- internal_error << "Aborting";
+ err << "Aborting";
+ internal_error << err.str();
  }
  }
 }
@@ -1039,8 +1041,7 @@ void FunctionDAG::featurize() {
  }
 }
 
-template<typename OS>
-void FunctionDAG::dump_internal(OS &os) const {
+void FunctionDAG::dump(std::ostream &os) const {
  for (const Node &n : nodes) {
  os << "Node: " << n.func.name() << "\n"
  << " Symbolic region required: \n";
@@ -1076,21 +1077,11 @@ void FunctionDAG::dump_internal(OS &os) const {
 
  os << " Load Jacobians:\n";
  for (const auto &jac : e.load_jacobians) {
- jac.dump(" ");
+ jac.dump(os, " ");
  }
  }
 }
 
-void FunctionDAG::dump() const {
- auto os = aslog(0);
- dump_internal(os);
-}
-
-std::ostream &FunctionDAG::dump(std::ostream &os) const {
- dump_internal(os);
- return os;
-}
-
 } // namespace Autoscheduler
 } // namespace Internal
 } // namespace Halide

src/autoschedulers/adams2019/FunctionDAG.h

@@ -205,7 +205,7 @@ class LoadJacobian {
  return result;
  }
 
- void dump(const char *prefix) const;
+ void dump(std::ostream &os, const char *prefix) const;
 };
 
 // Classes to represent a concrete set of bounds for a Func. A Span is
@@ -565,16 +565,12 @@ struct FunctionDAG {
  // analysis. This is done once up-front before the tree search.
  FunctionDAG(const vector<Function> &outputs, const MachineParams &params, const Target &target);
 
- void dump() const;
- std::ostream &dump(std::ostream &os) const;
+ void dump(std::ostream &os) const;
 
 private:
  // Compute the featurization for the entire DAG
  void featurize();
 
- template<typename OS>
- void dump_internal(OS &os) const;
-
 public:
  // This class uses a lot of internal pointers, so we'll make it uncopyable/unmovable.
  FunctionDAG(const FunctionDAG &other) = delete;