Convert LOG(INFO) to VLOG(1) - courgette/.

courgette/adjustment_method_2.cc

-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "courgette/adjustment_method.h"
 
 #include <algorithm>
 #include <limits>
 #include <list>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
-#include <iostream>
-
 #include "base/basictypes.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/time.h"
 
 #include "courgette/assembly_program.h"
 #include "courgette/courgette.h"
 #include "courgette/encoded_program.h"
 #include "courgette/image_info.h"
@@ skipping 119 matching lines @@
 this pattern, then there is no competing evidence and we go ahead with the
 assignment immediately.  This produces slightly better results because these
 cases tend to be low-scoring and susceptible to small mistakes made in
 low-scoring assignments in the approximation for large equivalence classes.
 
 */
 
 namespace courgette {
 namespace adjustment_method_2 {
 
-// We have three discretionary information logging levels for algorithm
-// development.  For now just configure with #defines.
-// TODO(sra): make dependent of some configurable setting.
-struct LogToCout {
-  LogToCout() {}
-  ~LogToCout() { std::cout << std::endl; }
-  std::ostream& stream() { return std::cout; }
-};
-#define LOG_TO_COUT (LogToCout().stream())
-#define NO_LOG DLOG_IF(INFO, false)
-
-#if 0   // Log to log file.
-#define ALOG1 LOG(INFO)
-#define ALOG2 LOG(INFO)
-#define ALOG3 LOG(INFO)
-#elif 0  // Log to stdout.
-#define ALOG1 LOG_TO_COUT
-#define ALOG2 LOG_TO_COUT
-#define ALOG3 LOG_TO_COUT
-#else   // Log to nowhere.
-#define ALOG1 NO_LOG
-#define ALOG2 NO_LOG
-#define ALOG3 NO_LOG
-#endif
-
 ////////////////////////////////////////////////////////////////////////////////
 
 class AssignmentCandidates;
 class LabelInfoMaker;
 class Shingle;
 class ShinglePattern;
 
 // The purpose of adjustment is to assign indexes to Labels of a program 'p' to
 // make the sequence of indexes similar to a 'model' program 'm'.  Labels
 // themselves don't have enough information to do this job, so we work with a
@@ skipping 150 matching lines @@
          ++p) {
       if (p->second != 0)
         Update(p->first, p->second);
       else
         ++zeroes;
     }
     pending_updates_.clear();
   }
 
   void Print(int max) {
-    ALOG1 << "score "  << TopScore() << "  " << ToString(program_info_)
-          << " := ?";
+    VLOG(2) << "score "  << TopScore() << "  " << ToString(program_info_)
+            << " := ?";
     if (!pending_updates_.empty())
-      ALOG1 << pending_updates_.size() << " pending";
+      VLOG(2) << pending_updates_.size() << " pending";
     int count = 0;
     for (Queue::iterator q = queue_.begin();  q != queue_.end();  ++q) {
       if (++count > max) break;
-      ALOG1 << "   " << q->first << "  " << ToString(q->second);
+      VLOG(2) << "   " << q->first << "  " << ToString(q->second);
     }
   }
 
  private:
   typedef std::map<LabelInfo*, int, OrderLabelInfo> LabelToScore;
   typedef std::pair<int, LabelInfo*> ScoreAndLabel;
   struct OrderScoreAndLabelByScoreDecreasing {
     OrderLabelInfo tie_breaker;
     bool operator()(const ScoreAndLabel& a, const ScoreAndLabel& b) const {
       if (a.first > b.first) return true;
@@ skipping 452 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(VariableQueue);
 };
 
 
 class AssignmentProblem {
  public:
   AssignmentProblem(const Trace& trace, size_t model_end)
       : trace_(trace),
         model_end_(model_end) {
-    ALOG1 << "AssignmentProblem::AssignmentProblem  " << model_end << ", "
-          << trace.size();
+    VLOG(2) << "AssignmentProblem::AssignmentProblem  " << model_end << ", "
+            << trace.size();
   }
 
   bool Solve() {
     if (model_end_ < Shingle::kWidth ||
         trace_.size() - model_end_ < Shingle::kWidth) {
       // Nothing much we can do with such a short problem.
       return true;
     }
     instances_.resize(trace_.size() - Shingle::kWidth + 1, NULL);
     AddShingles(0, model_end_);
     AddShingles(model_end_, trace_.size());
     InitialClassify();
     AddPatternsNeedingUpdatesToQueues();
 
     patterns_needing_updates_.clear();
-    while (FindAndAssignBestLeader()) {
-      NO_LOG << "Updated " << patterns_needing_updates_.size() << " patterns";
+    while (FindAndAssignBestLeader())
       patterns_needing_updates_.clear();
-    }
     PrintActivePatterns();
 
     return true;
   }
 
  private:
   typedef std::set<Shingle*, Shingle::PointerLess> ShingleSet;
 
   typedef std::set<const ShinglePattern*, ShinglePatternPointerLess>
       ShinglePatternSet;
 
   // Patterns are partitioned into the following sets:
 
   // * Retired patterns (not stored).  No shingles exist for this pattern (they
   //   all now match more specialized patterns).
   // * Useless patterns (not stored).  There are no 'program' shingles for this
   //   pattern (they all now match more specialized patterns).
   // * Single-use patterns - single_use_pattern_queue_.
   // * Other patterns - active_non_single_use_patterns_ / variable_queue_.
 
   typedef std::set<const ShinglePattern*,
                    OrderShinglePatternByScoreDescending<&SingleUseScore> >
       SingleUsePatternQueue;
 
   void PrintPatternsHeader() const {
-    ALOG1 << shingle_instances_.size() << " instances  "
-          << trace_.size() << " trace length  "
-          << patterns_.size() << " shingle indexes  "
-          << single_use_pattern_queue_.size() << " single use patterns  "
-          << active_non_single_use_patterns_.size() << " active patterns";
+    VLOG(2) << shingle_instances_.size() << " instances  "
+            << trace_.size() << " trace length  "
+            << patterns_.size() << " shingle indexes  "
+            << single_use_pattern_queue_.size() << " single use patterns  "
+            << active_non_single_use_patterns_.size() << " active patterns";
   }
 
   void PrintActivePatterns() const {
     for (ShinglePatternSet::const_iterator p =
              active_non_single_use_patterns_.begin();
          p != active_non_single_use_patterns_.end();
          ++p) {
       const ShinglePattern* pattern = *p;
-      ALOG1 << ToString(pattern, 10);
+      VLOG(2) << ToString(pattern, 10);
     }
   }
 
   void PrintPatterns() const {
     PrintAllPatterns();
     PrintActivePatterns();
     PrintAllShingles();
   }
 
   void PrintAllPatterns() const {
     for (IndexToPattern::const_iterator p = patterns_.begin();
          p != patterns_.end();
          ++p) {
       const ShinglePattern& pattern = p->second;
-      ALOG1 << ToString(&pattern, 10);
+      VLOG(2) << ToString(&pattern, 10);
     }
   }
 
   void PrintAllShingles() const {
     for (Shingle::OwningSet::const_iterator p = shingle_instances_.begin();
          p != shingle_instances_.end();
          ++p) {
       const Shingle& instance = *p;
-      ALOG1 << ToString(&instance) << "   " << ToString(instance.pattern());
+      VLOG(2) << ToString(&instance) << "   " << ToString(instance.pattern());
     }
   }
 
 
   void AddShingles(size_t begin, size_t end) {
     for (size_t i = begin;  i + Shingle::kWidth - 1 < end;  ++i) {
       instances_[i] = Shingle::Find(trace_, i, &shingle_instances_);
     }
   }
 
@@ skipping 161 matching lines @@
         const Shingle* program_instance = program_freq.instance();
 
         // int score = p1;  // ? weigh all equally??
         int score = std::min(p1, m1);
 
         for (size_t i = 0;  i < Shingle::kWidth;  ++i) {
           LabelInfo* program_info = program_instance->at(i);
           LabelInfo* model_info = model_instance->at(i);
           if ((model_info->assignment_ == NULL) !=
               (program_info->assignment_ == NULL)) {
-            ALOG1 << "ERROR " << i
-                  << "\n\t"  << ToString(pattern, 10)
-                  << "\n\t" << ToString(program_instance)
-                  << "\n\t" << ToString(model_instance);
+            VLOG(2) << "ERROR " << i
+                    << "\n\t"  << ToString(pattern, 10)
+                    << "\n\t" << ToString(program_instance)
+                    << "\n\t" << ToString(model_instance);
           }
           if (!program_info->assignment_ && !model_info->assignment_) {
             sums[program_info][model_info] += score;
           }
         }
 
         for (ScoreSet::iterator assignee_iterator = sums.begin();
              assignee_iterator != sums.end();
              ++assignee_iterator) {
           LabelInfo* program_info = assignee_iterator->first;
@@ skipping 22 matching lines @@
       }
     }
   }
 
   void AssignOne(LabelInfo* model_info, LabelInfo* program_info) {
     LOG_ASSERT(!model_info->assignment_);
     LOG_ASSERT(!program_info->assignment_);
     LOG_ASSERT(model_info->is_model_);
     LOG_ASSERT(!program_info->is_model_);
 
-    ALOG2 << "Assign " << ToString(program_info)
-          << " := " << ToString(model_info);
+    VLOG(3) << "Assign " << ToString(program_info)
+            << " := " << ToString(model_info);
 
     ShingleSet affected_shingles;
     AddAffectedPositions(model_info, &affected_shingles);
     AddAffectedPositions(program_info, &affected_shingles);
 
     for (ShingleSet::iterator p = affected_shingles.begin();
          p != affected_shingles.end();
          ++p) {
       patterns_needing_updates_.insert((*p)->pattern());
     }
@@ skipping 93 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(AssignmentProblem);
 };
 
 class Adjuster : public AdjustmentMethod {
  public:
   Adjuster() : prog_(NULL), model_(NULL) {}
   ~Adjuster() {}
 
   bool Adjust(const AssemblyProgram& model, AssemblyProgram* program) {
-    LOG(INFO) << "Adjuster::Adjust";
+    VLOG(1) << "Adjuster::Adjust";
     prog_ = program;
     model_ = &model;
     return Finish();
   }
 
   bool Finish() {
     prog_->UnassignIndexes();
     Trace abs32_trace_;
     Trace rel32_trace_;
     CollectTraces(model_, &abs32_trace_, &rel32_trace_, true);
@@ skipping 22 matching lines @@
     // incorporate some costing for entropy (bigger deltas) that will be
     // introduced into the label address table by non-monotonic ordering.  This
     // would have some knock-on effects to parts of the algorithm that work on
     // single-occurrence labels.
   }
 
   void Solve(const Trace& model, size_t model_end) {
     base::Time start_time = base::Time::Now();
     AssignmentProblem a(model, model_end);
     a.Solve();
-    LOG(INFO) << " Adjuster::Solve "
-              << (base::Time::Now() - start_time).InSecondsF();
+    VLOG(1) << " Adjuster::Solve "
+            << (base::Time::Now() - start_time).InSecondsF();
   }
 
   void ReferenceLabel(Trace* trace, Label* label, bool is_model) {
     trace->push_back(
         label_info_maker_.MakeLabelInfo(label, is_model, trace->size()));
   }
 
   AssemblyProgram* prog_;         // Program to be adjusted, owned by caller.
   const AssemblyProgram* model_;  // Program to be mimicked, owned by caller.
 
   LabelInfoMaker label_info_maker_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Adjuster);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 }  // namespace adjustment_method_2
 
 AdjustmentMethod* AdjustmentMethod::MakeShingleAdjustmentMethod() {
   return new adjustment_method_2::Adjuster();
 }
 
 }  // namespace courgette