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

courgette/adjustment_method.cc

 // 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 <list>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 
 #include "courgette/assembly_program.h"
 #include "courgette/courgette.h"
 #include "courgette/encoded_program.h"
 #include "courgette/image_info.h"
 
 namespace courgette {
 
-// We have three discretionary information logging levels for algorithm
-// development.  For now just configure with #defines.
-// TODO(sra): make dependent of some configurable setting.
-#define NO_LOG DLOG_IF(INFO, false)
-// #define ALOG1 LOG(INFO)
-// #define ALOG2 LOG(INFO)
-// #define ALOG3 LOG(INFO)
-#define ALOG1 NO_LOG
-#define ALOG2 NO_LOG
-#define ALOG3 NO_LOG
-
 ////////////////////////////////////////////////////////////////////////////////
 
 class NullAdjustmentMethod : public AdjustmentMethod {
   bool Adjust(const AssemblyProgram& model, AssemblyProgram* program) {
     return true;
   }
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ skipping 188 matching lines @@
     p_root_ = MakeRootNode(p_trace_);
     AddToQueue(p_root_);
 
     while (!worklist_.empty()) {
       Node* node = *worklist_.begin();
       node->in_queue_ = false;
       worklist_.erase(node);
       TrySolveNode(node);
     }
 
-    ALOG1 << unsolved_.size() << " unsolved items";
+    VLOG(2) << unsolved_.size() << " unsolved items";
     return true;
   }
 
  private:
   void AddToQueue(Node* node) {
     if (node->length_ >= 10) {
-      ALOG3 << "Length clipped " << ToString(node->prev_);
+      VLOG(4) << "Length clipped " << ToString(node->prev_);
       return;
     }
     if (node->in_queue_) {
       LOG(ERROR) << "Double add " << ToString(node);
       return;
     }
     // just to be sure data for prioritizing is available
     ExtendNode(node, p_trace_);
     // SkipCommittedLabels(node);
     if (node->edges_in_frequency_order.empty())
       return;
     node->in_queue_ = true;
     worklist_.insert(node);
   }
 
   void SkipCommittedLabels(Node* node) {
     ExtendNode(node, p_trace_);
     uint32 skipped = 0;
     while (!node->edges_in_frequency_order.empty() &&
            node->edges_in_frequency_order.front()->in_edge_->assignment_) {
       ++skipped;
       node->edges_in_frequency_order.pop_front();
     }
     if (skipped > 0)
-      ALOG3 << "Skipped " << skipped << " at " << ToString(node);
+      VLOG(4) << "Skipped " << skipped << " at " << ToString(node);
   }
 
   void TrySolveNode(Node* p_node) {
     Node* front = p_node->edges_in_frequency_order.front();
     if (front->in_edge_->assignment_) {
       p_node->edges_in_frequency_order.pop_front();
       AddToQueue(front);
       AddToQueue(p_node);
       return;
     }
 
     // Compare frequencies of unassigned edges, and either make
     // assignment(s) or move node to unsolved list
 
     Node* m_node = FindModelNode(p_node);
 
     if (m_node == NULL) {
-      ALOG1 << "Can't find model node";
+      VLOG(2) << "Can't find model node";
       unsolved_.insert(p_node);
       return;
     }
     ExtendNode(m_node, m_trace_);
 
     // Lets just try greedy
 
     SkipCommittedLabels(m_node);
     if (m_node->edges_in_frequency_order.empty()) {
-      ALOG3 << "Punting, no elements left in model vs "
-            << p_node->edges_in_frequency_order.size();
+      VLOG(4) << "Punting, no elements left in model vs "
+              << p_node->edges_in_frequency_order.size();
       unsolved_.insert(p_node);
       return;
     }
     Node* m_match = m_node->edges_in_frequency_order.front();
     Node* p_match = p_node->edges_in_frequency_order.front();
 
     if (p_match->count_ > 1.1 * m_match->count_  ||
         m_match->count_ > 1.1 * p_match->count_) {
-      ALOG2 << "Tricky distribution "
-            << p_match->count_ << ":" << m_match->count_ << "  "
-            << ToString(p_match) << " vs " << ToString(m_match);
+      VLOG(3) << "Tricky distribution "
+              << p_match->count_ << ":" << m_match->count_ << "  "
+              << ToString(p_match) << " vs " << ToString(m_match);
       return;
     }
 
     m_node->edges_in_frequency_order.pop_front();
     p_node->edges_in_frequency_order.pop_front();
 
     LabelInfo* p_label_info = p_match->in_edge_;
     LabelInfo* m_label_info = m_match->in_edge_;
     int m_index = p_label_info->label_->index_;
     if (m_index != Label::kNoIndex) {
-      ALOG1 << "Cant use unassigned label from model " << m_index;
+      VLOG(2) << "Cant use unassigned label from model " << m_index;
       unsolved_.insert(p_node);
       return;
     }
 
     Assign(p_label_info, m_label_info);
 
     AddToQueue(p_match);  // find matches within new match
     AddToQueue(p_node);   // and more matches within this node
   }
 
   void Assign(LabelInfo* p_info, LabelInfo* m_info) {
     AssignOne(p_info, m_info);
-    ALOG3 << "Assign " << ToString(p_info) << " := " << ToString(m_info);
+    VLOG(4) << "Assign " << ToString(p_info) << " := " << ToString(m_info);
     // Now consider unassigned adjacent addresses
     TryExtendAssignment(p_info, m_info);
   }
 
   void AssignOne(LabelInfo* p_info, LabelInfo* m_info) {
     p_info->label_->index_ = m_info->label_->index_;
 
     // Mark as assigned
     m_info->assignment_ = p_info;
     p_info->assignment_ = m_info;
@@ skipping 27 matching lines @@
           break;
         }
       }
 
       // The label has inconsistent numbers of references, it is probably not
       // the same thing.
       if (m_info_next->refs_ != p_info_next->refs_) {
         break;
       }
 
-      ALOG3 << "  Extending assignment -> "
-            << ToString(p_info_next) << " := " << ToString(m_info_next);
+      VLOG(4) << "  Extending assignment -> "
+              << ToString(p_info_next) << " := " << ToString(m_info_next);
 
       AssignOne(p_info_next, m_info_next);
 
       if (p_info_next->refs_ == m_info_next->refs_ &&
           p_info_next->refs_ == 1) {
         TryExtendSequence(p_info_next->positions_[0],
                           m_info_next->positions_[0]);
         TryExtendSequenceBackwards(p_info_next->positions_[0],
                                    m_info_next->positions_[0]);
       }
@@ skipping 18 matching lines @@
       LabelInfo* m_info_prev_prev = m_info_prev->prev_addr_;
       LabelInfo* p_info_prev_prev = p_info_prev->prev_addr_;
 
       // The the label has inconsistent numbers of references, it is
       // probably not the same thing
       if (m_info_prev->refs_ != p_info_prev->refs_) {
         break;
       }
 
       AssignOne(p_info_prev, m_info_prev);
-      ALOG3 << "  Extending assignment <- " << ToString(p_info_prev) << " := "
-            << ToString(m_info_prev);
+      VLOG(4) << "  Extending assignment <- " << ToString(p_info_prev) << " := "
+              << ToString(m_info_prev);
 
       p_info_prev = p_info_prev_prev;
       m_info_prev = m_info_prev_prev;
     }
   }
 
   uint32 TryExtendSequence(uint32 p_pos_start, uint32 m_pos_start) {
     uint32 p_pos = p_pos_start + 1;
     uint32 m_pos = m_pos_start + 1;
 
@@ skipping 11 matching lines @@
           break;
         ++p_pos;
         ++m_pos;
         continue;
       }
 
       if (p_info->refs_ != m_info->refs_)
         break;
 
       AssignOne(p_info, m_info);
-      ALOG3 << "    Extending assignment seq"
-            << "[+" << p_pos - p_pos_start << "]"
-            << " -> "
-            << ToString(p_info) << " := " << ToString(m_info);
+      VLOG(4) << "    Extending assignment seq[+" << p_pos - p_pos_start
+              << "] -> " << ToString(p_info) << " := " << ToString(m_info);
 
       ++p_pos;
       ++m_pos;
     }
 
     return p_pos - p_pos_start;
   }
 
   uint32 TryExtendSequenceBackwards(uint32 p_pos_start, uint32 m_pos_start) {
     if (p_pos_start == 0  ||  m_pos_start == 0)
@@ skipping 14 matching lines @@
           break;
         --p_pos;
         --m_pos;
         continue;
       }
 
       if (p_info->refs_ != m_info->refs_)
         break;
 
       AssignOne(p_info, m_info);
-      ALOG3 << "    Extending assignment seq"
-            << "[-" << p_pos_start - p_pos << "]"
-            << " <- "
-            << ToString(p_info) << " := " << ToString(m_info);
+      VLOG(4) << "    Extending assignment seq[-" << p_pos_start - p_pos
+              << "] <- " << ToString(p_info) << " := " << ToString(m_info);
 
       --p_pos;
       --m_pos;
     }
 
     return p_pos - p_pos_start;
   }
 
   Node* FindModelNode(Node* node) {
     if (node->prev_ == NULL)
       return m_root_;
 
     Node* m_parent = FindModelNode(node->prev_);
     if (m_parent == NULL) {
       return NULL;
     }
 
     ExtendNode(m_parent, m_trace_);
 
     LabelInfo* p_label = node->in_edge_;
     LabelInfo* m_label = p_label->assignment_;
     if (m_label == NULL) {
-      ALOG1 << "Expected assigned prefix";
+      VLOG(2) << "Expected assigned prefix";
       return NULL;
     }
 
     Node::Edges::iterator e = m_parent->edges_.find(m_label);
     if (e == m_parent->edges_.end()) {
-      ALOG2 << "Expected defined edge in parent";
+      VLOG(3) << "Expected defined edge in parent";
       return NULL;
     }
 
     return e->second;
   }
 
   Node* MakeRootNode(const Trace& trace) {
     Node* node = new Node(NULL, NULL);
     all_nodes_.push_back(node);
     for (size_t i = 0;  i < trace.size();  ++i) {
@@ skipping 39 matching lines @@
 
 class GraphAdjuster : public AdjustmentMethod {
  public:
   GraphAdjuster()
       : prog_(NULL),
         model_(NULL),
         debug_label_index_gen_(0) {}
   ~GraphAdjuster() {}
 
   bool Adjust(const AssemblyProgram& model, AssemblyProgram* program) {
-    LOG(INFO) << "GraphAdjuster::Adjust";
+    VLOG(1) << "GraphAdjuster::Adjust";
     prog_ = program;
     model_ = &model;
     debug_label_index_gen_ = 0;
     return Finish();
   }
 
   bool Finish() {
     prog_->UnassignIndexes();
     CollectTraces(model_, &model_abs32_, &model_rel32_, true);
     CollectTraces(prog_,  &prog_abs32_,  &prog_rel32_,  false);
@@ skipping 97 matching lines @@
   AdjustmentMethod* method = AdjustmentMethod::MakeProductionAdjustmentMethod();
   bool ok = method->Adjust(model, program);
   method->Destroy();
   if (ok)
     return C_OK;
   else
     return C_ADJUSTMENT_FAILED;
 }
 
 }  // namespace courgette