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

runtime/vm/benchmark_test.cc

 // Copyright (c) 2012, 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/benchmark_test.h"
 
 #include "bin/builtin.h"
 #include "bin/file.h"
 #include "bin/isolate_data.h"
 
 #include "platform/assert.h"
 #include "platform/globals.h"
 
 #include "vm/clustered_snapshot.h"
 #include "vm/compiler_stats.h"
 #include "vm/dart_api_impl.h"
 #include "vm/stack_frame.h"
 #include "vm/unit_test.h"
 
 using dart::bin::File;
 
 namespace dart {
 
 Benchmark* Benchmark::first_ = NULL;
 Benchmark* Benchmark::tail_ = NULL;
 const char* Benchmark::executable_ = NULL;
 
-
 //
 // Measure compile of all dart2js(compiler) functions.
 //
 static char* ComputeDart2JSPath(const char* arg) {
   char buffer[2048];
   char* dart2js_path = strdup(File::GetCanonicalPath(arg));
   const char* compiler_path = "%s%spkg%scompiler%slib%scompiler.dart";
   const char* path_separator = File::PathSeparator();
   ASSERT(path_separator != NULL && strlen(path_separator) == 1);
   char* ptr = strrchr(dart2js_path, *path_separator);
   while (ptr != NULL) {
     *ptr = '\0';
     OS::SNPrint(buffer, 2048, compiler_path, dart2js_path, path_separator,
                 path_separator, path_separator, path_separator, path_separator);
     if (File::Exists(buffer)) {
       break;
     }
     ptr = strrchr(dart2js_path, *path_separator);
   }
   if (ptr == NULL) {
     free(dart2js_path);
     dart2js_path = NULL;
   }
   return dart2js_path;
 }
 
-
 static void func(Dart_NativeArguments args) {}
 
-
 static Dart_NativeFunction NativeResolver(Dart_Handle name,
                                           int arg_count,
                                           bool* auto_setup_scope) {
   ASSERT(auto_setup_scope != NULL);
   *auto_setup_scope = false;
   return &func;
 }
 
-
 static void SetupDart2JSPackagePath() {
   bool worked = bin::DartUtils::SetOriginalWorkingDirectory();
   EXPECT(worked);
 
   Dart_Handle result = bin::DartUtils::PrepareForScriptLoading(false, false);
   DART_CHECK_VALID(result);
 
   // Setup package root.
   char buffer[2048];
   char* executable_path =
       strdup(File::GetCanonicalPath(Benchmark::Executable()));
   const char* packages_path = "%s%s..%spackages";
   const char* path_separator = File::PathSeparator();
   OS::SNPrint(buffer, 2048, packages_path, executable_path, path_separator,
               path_separator);
   result = bin::DartUtils::SetupPackageRoot(buffer, NULL);
   DART_CHECK_VALID(result);
 }
 
-
 void Benchmark::RunAll(const char* executable) {
   SetExecutable(executable);
   Benchmark* benchmark = first_;
   while (benchmark != NULL) {
     benchmark->RunBenchmark();
     benchmark = benchmark->next_;
   }
 }
 
-
 Dart_Isolate Benchmark::CreateIsolate(const uint8_t* snapshot_data,
                                       const uint8_t* snapshot_instructions) {
   char* err = NULL;
   isolate_ = Dart_CreateIsolate(NULL, NULL, snapshot_data,
                                 snapshot_instructions, NULL, NULL, &err);
   EXPECT(isolate_ != NULL);
   free(err);
   return isolate_;
 }
 
-
 //
 // Measure compile of all functions in dart core lib classes.
 //
 BENCHMARK(CorelibCompileAll) {
   bin::Builtin::SetNativeResolver(bin::Builtin::kBuiltinLibrary);
   bin::Builtin::SetNativeResolver(bin::Builtin::kIOLibrary);
   TransitionNativeToVM transition(thread);
   Timer timer(true, "Compile all of Core lib benchmark");
   timer.Start();
   const Error& error = Error::Handle(Library::CompileAll());
   if (!error.IsNull()) {
     OS::PrintErr("Unexpected error in CorelibCompileAll benchmark:\n%s",
                  error.ToErrorCString());
   }
   timer.Stop();
   int64_t elapsed_time = timer.TotalElapsedTime();
   benchmark->set_score(elapsed_time);
 }
 
-
 #ifndef PRODUCT
 
-
 BENCHMARK(CorelibCompilerStats) {
   bin::Builtin::SetNativeResolver(bin::Builtin::kBuiltinLibrary);
   bin::Builtin::SetNativeResolver(bin::Builtin::kIOLibrary);
   TransitionNativeToVM transition(thread);
   CompilerStats* stats = thread->isolate()->aggregate_compiler_stats();
   ASSERT(stats != NULL);
   stats->EnableBenchmark();
   Timer timer(true, "Compiler stats compiling all of Core lib");
   timer.Start();
   const Error& error = Error::Handle(Library::CompileAll());
   if (!error.IsNull()) {
     OS::PrintErr("Unexpected error in CorelibCompileAll benchmark:\n%s",
                  error.ToErrorCString());
   }
   timer.Stop();
   int64_t elapsed_time = timer.TotalElapsedTime();
   benchmark->set_score(elapsed_time);
 }
 
-
 BENCHMARK(Dart2JSCompilerStats) {
   bin::Builtin::SetNativeResolver(bin::Builtin::kBuiltinLibrary);
   bin::Builtin::SetNativeResolver(bin::Builtin::kIOLibrary);
   SetupDart2JSPackagePath();
   char* dart_root = ComputeDart2JSPath(Benchmark::Executable());
   char* script = NULL;
   if (dart_root != NULL) {
     HANDLESCOPE(thread);
     script = OS::SCreate(NULL, "import '%s/pkg/compiler/lib/compiler.dart';",
                          dart_root);
@@ skipping 21 matching lines @@
   FLAG_background_compilation = old_flag;
 #endif
   EXPECT_VALID(result);
   timer.Stop();
   int64_t elapsed_time = timer.TotalElapsedTime();
   benchmark->set_score(elapsed_time);
   free(dart_root);
   free(script);
 }
 
-
 #endif  // !PRODUCT
 
-
 //
 // Measure creation of core isolate from a snapshot.
 //
 BENCHMARK(CorelibIsolateStartup) {
   const int kNumIterations = 1000;
   Timer timer(true, "CorelibIsolateStartup");
   Isolate* isolate = thread->isolate();
   Dart_ExitIsolate();
   for (int i = 0; i < kNumIterations; i++) {
     timer.Start();
     TestCase::CreateTestIsolate();
     timer.Stop();
     Dart_ShutdownIsolate();
   }
   benchmark->set_score(timer.TotalElapsedTime() / kNumIterations);
   Dart_EnterIsolate(reinterpret_cast<Dart_Isolate>(isolate));
 }
 
-
 //
 // Measure invocation of Dart API functions.
 //
 static void InitNativeFields(Dart_NativeArguments args) {
   Dart_EnterScope();
   int count = Dart_GetNativeArgumentCount(args);
   EXPECT_EQ(1, count);
 
   Dart_Handle recv = Dart_GetNativeArgument(args, 0);
   EXPECT_VALID(recv);
   Dart_Handle result = Dart_SetNativeInstanceField(recv, 0, 7);
   EXPECT_VALID(result);
 
   Dart_ExitScope();
 }
 
-
 // The specific api functions called here are a bit arbitrary.  We are
 // trying to get a sense of the overhead for using the dart api.
 static void UseDartApi(Dart_NativeArguments args) {
   int count = Dart_GetNativeArgumentCount(args);
   EXPECT_EQ(3, count);
 
   // Get native field from receiver.
   intptr_t receiver_value;
   Dart_Handle result = Dart_GetNativeReceiver(args, &receiver_value);
   EXPECT_VALID(result);
@@ skipping 10 matching lines @@
   int64_t value1;
   result = Dart_IntegerToInt64(param1, &value1);
   EXPECT_VALID(result);
   EXPECT_LE(0, value1);
   EXPECT_LE(value1, 1000000);
 
   // Return param + receiver.field.
   Dart_SetReturnValue(args, Dart_NewInteger(value1 * receiver_value));
 }
 
-
 static Dart_NativeFunction bm_uda_lookup(Dart_Handle name,
                                          int argument_count,
                                          bool* auto_setup_scope) {
   ASSERT(auto_setup_scope != NULL);
   *auto_setup_scope = true;
   const char* cstr = NULL;
   Dart_Handle result = Dart_StringToCString(name, &cstr);
   EXPECT_VALID(result);
   if (strcmp(cstr, "init") == 0) {
     return InitNativeFields;
   } else {
     return UseDartApi;
   }
 }
 
-
 BENCHMARK(UseDartApi) {
   const int kNumIterations = 1000000;
   const char* kScriptChars =
       "class Class extends NativeFieldsWrapper{\n"
       "  int init() native 'init';\n"
       "  int method(int param1, int param2) native 'method';\n"
       "}\n"
       "\n"
       "void benchmark(int count) {\n"
       "  Class c = new Class();\n"
@@ skipping 21 matching lines @@
   Dart_Invoke(lib, NewString("benchmark"), 1, args);
 
   Timer timer(true, "UseDartApi benchmark");
   timer.Start();
   Dart_Invoke(lib, NewString("benchmark"), 1, args);
   timer.Stop();
   int64_t elapsed_time = timer.TotalElapsedTime();
   benchmark->set_score(elapsed_time);
 }
 
-
 //
 // Measure time accessing internal and external strings.
 //
 BENCHMARK(DartStringAccess) {
   const int kNumIterations = 10000000;
   Timer timer(true, "DartStringAccess benchmark");
   timer.Start();
   Dart_EnterScope();
 
   // Create strings.
@@ skipping 18 matching lines @@
     EXPECT_EQ(4, str_len);
     EXPECT_EQ(&external_peer_data, external_peer);
   }
 
   Dart_ExitScope();
   timer.Stop();
   int64_t elapsed_time = timer.TotalElapsedTime();
   benchmark->set_score(elapsed_time);
 }
 
-
 BENCHMARK(Dart2JSCompileAll) {
   bin::Builtin::SetNativeResolver(bin::Builtin::kBuiltinLibrary);
   bin::Builtin::SetNativeResolver(bin::Builtin::kIOLibrary);
   SetupDart2JSPackagePath();
   char* dart_root = ComputeDart2JSPath(Benchmark::Executable());
   char* script = NULL;
   if (dart_root != NULL) {
     HANDLESCOPE(thread);
     script = OS::SCreate(NULL, "import '%s/pkg/compiler/lib/compiler.dart';",
                          dart_root);
@@ skipping 17 matching lines @@
   FLAG_background_compilation = old_flag;
 #endif
   EXPECT_VALID(result);
   timer.Stop();
   int64_t elapsed_time = timer.TotalElapsedTime();
   benchmark->set_score(elapsed_time);
   free(dart_root);
   free(script);
 }
 
-
 //
 // Measure frame lookup during stack traversal.
 //
 static void StackFrame_accessFrame(Dart_NativeArguments args) {
   const int kNumIterations = 100;
   Code& code = Code::Handle();
   Timer timer(true, "LookupDartCode benchmark");
   timer.Start();
   for (int i = 0; i < kNumIterations; i++) {
     StackFrameIterator frames(StackFrameIterator::kDontValidateFrames,
                               Thread::Current(),
                               StackFrameIterator::kNoCrossThreadIteration);
     StackFrame* frame = frames.NextFrame();
     while (frame != NULL) {
       if (frame->IsStubFrame()) {
         code = frame->LookupDartCode();
         EXPECT(code.function() == Function::null());
       } else if (frame->IsDartFrame()) {
         code = frame->LookupDartCode();
         EXPECT(code.function() != Function::null());
       }
       frame = frames.NextFrame();
     }
   }
   timer.Stop();
   int64_t elapsed_time = timer.TotalElapsedTime();
   Dart_SetReturnValue(args, Dart_NewInteger(elapsed_time));
 }
 
-
 static Dart_NativeFunction StackFrameNativeResolver(Dart_Handle name,
                                                     int arg_count,
                                                     bool* auto_setup_scope) {
   ASSERT(auto_setup_scope != NULL);
   *auto_setup_scope = false;
   return &StackFrame_accessFrame;
 }
 
-
 // Unit test case to verify stack frame iteration.
 BENCHMARK(FrameLookup) {
   const char* kScriptChars =
       "class StackFrame {"
       "  static int accessFrame() native \"StackFrame_accessFrame\";"
       "} "
       "class First {"
       "  First() { }"
       "  int method1(int param) {"
       "    if (param == 1) {"
@@ skipping 32 matching lines @@
       reinterpret_cast<Dart_NativeEntryResolver>(StackFrameNativeResolver));
   Dart_Handle cls = Dart_GetClass(lib, NewString("StackFrameTest"));
   Dart_Handle result = Dart_Invoke(cls, NewString("testMain"), 0, NULL);
   EXPECT_VALID(result);
   int64_t elapsed_time = 0;
   result = Dart_IntegerToInt64(result, &elapsed_time);
   EXPECT_VALID(result);
   benchmark->set_score(elapsed_time);
 }
 
-
 static uint8_t* malloc_allocator(uint8_t* ptr,
                                  intptr_t old_size,
                                  intptr_t new_size) {
   return reinterpret_cast<uint8_t*>(realloc(ptr, new_size));
 }
 
-
 static void malloc_deallocator(uint8_t* ptr) {
   free(ptr);
 }
 
-
 BENCHMARK_SIZE(CoreSnapshotSize) {
   const char* kScriptChars =
       "import 'dart:async';\n"
       "import 'dart:core';\n"
       "import 'dart:collection';\n"
       "import 'dart:_internal';\n"
       "import 'dart:math';\n"
       "import 'dart:isolate';\n"
       "import 'dart:mirrors';\n"
       "import 'dart:typed_data';\n"
@@ skipping 14 matching lines @@
   writer.WriteFullSnapshot();
   const Snapshot* snapshot =
       Snapshot::SetupFromBuffer(isolate_snapshot_data_buffer);
   ASSERT(snapshot->kind() == Snapshot::kFull);
   benchmark->set_score(snapshot->length());
 
   free(vm_snapshot_data_buffer);
   free(isolate_snapshot_data_buffer);
 }
 
-
 BENCHMARK_SIZE(StandaloneSnapshotSize) {
   const char* kScriptChars =
       "import 'dart:async';\n"
       "import 'dart:core';\n"
       "import 'dart:collection';\n"
       "import 'dart:_internal';\n"
       "import 'dart:convert';\n"
       "import 'dart:math';\n"
       "import 'dart:isolate';\n"
       "import 'dart:mirrors';\n"
@@ skipping 17 matching lines @@
   writer.WriteFullSnapshot();
   const Snapshot* snapshot =
       Snapshot::SetupFromBuffer(isolate_snapshot_data_buffer);
   ASSERT(snapshot->kind() == Snapshot::kFull);
   benchmark->set_score(snapshot->length());
 
   free(vm_snapshot_data_buffer);
   free(isolate_snapshot_data_buffer);
 }
 
-
 BENCHMARK(CreateMirrorSystem) {
   const char* kScriptChars =
       "import 'dart:mirrors';\n"
       "\n"
       "void benchmark() {\n"
       "  currentMirrorSystem();\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   Timer timer(true, "currentMirrorSystem() benchmark");
   timer.Start();
   Dart_Invoke(lib, NewString("benchmark"), 0, NULL);
   timer.Stop();
   int64_t elapsed_time = timer.TotalElapsedTime();
   benchmark->set_score(elapsed_time);
 }
 
-
 BENCHMARK(EnterExitIsolate) {
   const char* kScriptChars =
       "import 'dart:core';\n"
       "\n";
   const intptr_t kLoopCount = 1000000;
   TestCase::LoadTestScript(kScriptChars, NULL);
   Api::CheckAndFinalizePendingClasses(thread);
   Dart_Isolate isolate = Dart_CurrentIsolate();
   Timer timer(true, "Enter and Exit isolate");
   timer.Start();
   for (intptr_t i = 0; i < kLoopCount; i++) {
     Dart_ExitIsolate();
     Dart_EnterIsolate(isolate);
   }
   timer.Stop();
   int64_t elapsed_time = timer.TotalElapsedTime();
   benchmark->set_score(elapsed_time);
 }
 
-
 static uint8_t message_buffer[64];
 static uint8_t* message_allocator(uint8_t* ptr,
                                   intptr_t old_size,
                                   intptr_t new_size) {
   return message_buffer;
 }
 static void message_deallocator(uint8_t* ptr) {}
 
-
 BENCHMARK(SerializeNull) {
   const Object& null_object = Object::Handle();
   const intptr_t kLoopCount = 1000000;
   uint8_t* buffer;
   Timer timer(true, "Serialize Null");
   timer.Start();
   for (intptr_t i = 0; i < kLoopCount; i++) {
     StackZone zone(thread);
     MessageWriter writer(&buffer, &message_allocator, &message_deallocator,
                          true);
     writer.WriteMessage(null_object);
     intptr_t buffer_len = writer.BytesWritten();
 
     // Read object back from the snapshot.
     MessageSnapshotReader reader(buffer, buffer_len, thread);
     reader.ReadObject();
   }
   timer.Stop();
   int64_t elapsed_time = timer.TotalElapsedTime();
   benchmark->set_score(elapsed_time);
 }
 
-
 BENCHMARK(SerializeSmi) {
   const Integer& smi_object = Integer::Handle(Smi::New(42));
   const intptr_t kLoopCount = 1000000;
   uint8_t* buffer;
   Timer timer(true, "Serialize Smi");
   timer.Start();
   for (intptr_t i = 0; i < kLoopCount; i++) {
     StackZone zone(thread);
     MessageWriter writer(&buffer, &message_allocator, &message_deallocator,
                          true);
     writer.WriteMessage(smi_object);
     intptr_t buffer_len = writer.BytesWritten();
 
     // Read object back from the snapshot.
     MessageSnapshotReader reader(buffer, buffer_len, thread);
     reader.ReadObject();
   }
   timer.Stop();
   int64_t elapsed_time = timer.TotalElapsedTime();
   benchmark->set_score(elapsed_time);
 }
 
-
 BENCHMARK(SimpleMessage) {
   TransitionNativeToVM transition(thread);
   const Array& array_object = Array::Handle(Array::New(2));
   array_object.SetAt(0, Integer::Handle(Smi::New(42)));
   array_object.SetAt(1, Object::Handle());
   const intptr_t kLoopCount = 1000000;
   uint8_t* buffer;
   Timer timer(true, "Simple Message");
   timer.Start();
   for (intptr_t i = 0; i < kLoopCount; i++) {
     StackZone zone(thread);
     MessageWriter writer(&buffer, &malloc_allocator, &malloc_deallocator, true);
     writer.WriteMessage(array_object);
     intptr_t buffer_len = writer.BytesWritten();
 
     // Read object back from the snapshot.
     MessageSnapshotReader reader(buffer, buffer_len, thread);
     reader.ReadObject();
     free(buffer);
   }
   timer.Stop();
   int64_t elapsed_time = timer.TotalElapsedTime();
   benchmark->set_score(elapsed_time);
 }
 
-
 BENCHMARK(LargeMap) {
   const char* kScript =
       "makeMap() {\n"
       "  Map m = {};\n"
       "  for (int i = 0; i < 100000; ++i) m[i*13+i*(i>>7)] = i;\n"
       "  return m;\n"
       "}";
   Dart_Handle h_lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(h_lib);
   Dart_Handle h_result = Dart_Invoke(h_lib, NewString("makeMap"), 0, NULL);
@@ skipping 13 matching lines @@
     // Read object back from the snapshot.
     MessageSnapshotReader reader(buffer, buffer_len, thread);
     reader.ReadObject();
     free(buffer);
   }
   timer.Stop();
   int64_t elapsed_time = timer.TotalElapsedTime();
   benchmark->set_score(elapsed_time);
 }
 
-
 BENCHMARK_MEMORY(InitialRSS) {
   benchmark->set_score(OS::MaxRSS());
 }
 
 }  // namespace dart