VM: Re-format to use at most one newline between functions

runtime/vm/compiler_stats.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/compiler_stats.h"
 
 #include "vm/flags.h"
 #include "vm/log.h"
 #include "vm/object_graph.h"
 #include "vm/object_store.h"
 #include "vm/timer.h"
 
-
 namespace dart {
 
 DEFINE_FLAG(bool, compiler_stats, false, "Compiler stat counters.");
 DEFINE_FLAG(bool,
             compiler_benchmark,
             false,
             "Compiler stat counters for benchmark.");
 
-
 class TokenStreamVisitor : public ObjectVisitor {
  public:
   explicit TokenStreamVisitor(CompilerStats* compiler_stats)
       : obj_(Object::Handle()), stats_(compiler_stats) {}
 
   void VisitObject(RawObject* raw_obj) {
     if (raw_obj->IsPseudoObject()) {
       return;  // Cannot be wrapped in handles.
     }
     obj_ = raw_obj;
     if (obj_.GetClassId() == TokenStream::kClassId) {
       TokenStream::Iterator tkit(
           Thread::Current()->zone(), TokenStream::Cast(obj_),
           TokenPosition::kMinSource, TokenStream::Iterator::kNoNewlines);
       Token::Kind kind = tkit.CurrentTokenKind();
       while (kind != Token::kEOS) {
         ++stats_->num_tokens_total;
         tkit.Advance();
         kind = tkit.CurrentTokenKind();
       }
     }
   }
 
  private:
   Object& obj_;
   CompilerStats* stats_;
 };
 
-
 CompilerStats::CompilerStats(Isolate* isolate)
     : isolate_(isolate),
 #define INITIALIZE_TIMER(timer_name, description) timer_name(true, description),
       STAT_TIMERS(INITIALIZE_TIMER)
 #undef INITIALIZE_TIMER
 
 #define INITIALIZE_COUNTERS(counter_name) counter_name(0),
           STAT_COUNTERS(INITIALIZE_COUNTERS)
 #undef INITIALIZE_COUNTERS
               text(NULL),
       use_benchmark_output(false) {
 }
 
-
 #ifndef PRODUCT
 
-
 // Used to aggregate stats. Must be atomic.
 void CompilerStats::Add(const CompilerStats& other) {
 #define ADD_TOTAL(timer_name, literal) timer_name.AddTotal(other.timer_name);
 
   STAT_TIMERS(ADD_TOTAL)
 #undef ADD_TOTAL
 
 #define ADD_COUNTER(counter_name)                                              \
   AtomicOperations::IncrementInt64By(&counter_name, other.counter_name);
 
   STAT_COUNTERS(ADD_COUNTER)
 #undef ADD_COUNTER
 }
 
-
 void CompilerStats::Clear() {
 #define CLEAR_TIMER(timer_name, literal) timer_name.Reset();
 
   STAT_TIMERS(CLEAR_TIMER)
 #undef CLEAR_TIMER
 
 #define CLEAR_COUNTER(counter_name) counter_name = 0;
 
   STAT_COUNTERS(CLEAR_COUNTER)
 #undef CLEAR_COUNTER
 }
 
-
 bool CompilerStats::IsCleared() const {
 #define CHECK_TIMERS(timer_name, literal)                                      \
   if (!timer_name.IsReset()) return false;
 
   STAT_TIMERS(CHECK_TIMERS)
 #undef CHECK_TIMERS
 
 #define CHECK_COUNTERS(counter_name)                                           \
   if (counter_name != 0) return false;
 
   STAT_COUNTERS(CHECK_COUNTERS)
 #undef CHECK_COUNTERS
   return true;
 }
 
-
 // This function is used as a callback in the log object to which the
 // compiler stats are printed. It will be called only once, to print
 // the accumulated text when all of the compiler stats values are
 // added to the log.
 static void PrintToStats(const char* format, ...) PRINTF_ATTRIBUTE(1, 2);
 static void PrintToStats(const char* format, ...) {
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   CompilerStats* stats = isolate->aggregate_compiler_stats();
   Zone* zone = thread->zone();
   ASSERT(stats != NULL);
   va_list args;
   va_start(args, format);
   stats->text = zone->VPrint(format, args);
   va_end(args);
 }
 
-
 void CompilerStats::Update() {
   // Traverse the heap and compute number of tokens in all
   // TokenStream objects.
   num_tokens_total = 0;
   TokenStreamVisitor visitor(this);
   isolate_->heap()->IterateObjects(&visitor);
   Dart::vm_isolate()->heap()->IterateObjects(&visitor);
 }
 
-
 void CompilerStats::EnableBenchmark() {
   FLAG_compiler_stats = true;
   use_benchmark_output = true;
 }
 
-
 // Generate output for Golem benchmark harness. If the output format
 // changes, the parsing function in Golem must be updated.
 char* CompilerStats::BenchmarkOutput() {
   Update();
   Log log(PrintToStats);
   LogBlock lb(Thread::Current(), &log);
   log.Print("==== Compiler Stats for isolate '%s' ====\n",
             isolate_->debugger_name());
 
   log.Print("NumberOfTokens: %" Pd64 "\n", num_tokens_total);
@@ skipping 34 matching lines @@
           : 0;
 
   log.Print("CodeDensity: %" Pd64 " tokens/KB\n", code_density);
   log.Print("InstrSize: %" Pd64 " KB\n", total_instr_size / 1024);
   log.Flush();
   char* benchmark_text = text;
   text = NULL;
   return benchmark_text;
 }
 
-
 char* CompilerStats::PrintToZone() {
   if (!FLAG_compiler_stats) {
     return NULL;
   } else if (use_benchmark_output) {
     return BenchmarkOutput();
   }
 
   Update();
 
   Log log(PrintToStats);
@@ skipping 95 matching lines @@
   log.Print("  VarDesc size:          %" Pd64 " KB\n", vardesc_size / 1024);
   log.Flush();
   char* stats_text = text;
   text = NULL;
   return stats_text;
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart