clang-format runtime/vm

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"
 
@@ skipping 14 matching lines @@
 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* 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);
+    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 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);
+  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();
@@ skipping 56 matching lines @@
 
 
 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);
+    script = OS::SCreate(NULL, "import '%s/pkg/compiler/lib/compiler.dart';",
+                         dart_root);
     Dart_Handle lib = TestCase::LoadTestScript(
-        script,
-        reinterpret_cast<Dart_NativeEntryResolver>(NativeResolver));
+        script, reinterpret_cast<Dart_NativeEntryResolver>(NativeResolver));
     EXPECT_VALID(lib);
   } else {
     Dart_Handle lib = TestCase::LoadTestScript(
         "import 'pkg/compiler/lib/compiler.dart';",
         reinterpret_cast<Dart_NativeEntryResolver>(NativeResolver));
     EXPECT_VALID(lib);
   }
   CompilerStats* stats = thread->isolate()->aggregate_compiler_stats();
   ASSERT(stats != NULL);
   stats->EnableBenchmark();
@@ skipping 113 matching lines @@
       "\n"
       "void benchmark(int count) {\n"
       "  Class c = new Class();\n"
       "  c.init();\n"
       "  for (int i = 0; i < count; i++) {\n"
       "    c.method(i,7);\n"
       "  }\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(
-      kScriptChars,
-      reinterpret_cast<Dart_NativeEntryResolver>(bm_uda_lookup),
-      USER_TEST_URI,
-      false);
+      kScriptChars, reinterpret_cast<Dart_NativeEntryResolver>(bm_uda_lookup),
+      USER_TEST_URI, false);
 
   // Create a native wrapper class with native fields.
-  Dart_Handle result = Dart_CreateNativeWrapperClass(
-      lib, NewString("NativeFieldsWrapper"), 1);
+  Dart_Handle result =
+      Dart_CreateNativeWrapperClass(lib, NewString("NativeFieldsWrapper"), 1);
   EXPECT_VALID(result);
   result = Dart_FinalizeLoading(false);
   EXPECT_VALID(result);
 
   Dart_Handle args[1];
   args[0] = Dart_NewInteger(kNumIterations);
 
   // Warmup first to avoid compilation jitters.
   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.
-  uint8_t data8[] = { 'o', 'n', 'e', 0xFF };
+  uint8_t data8[] = {'o', 'n', 'e', 0xFF};
   int external_peer_data = 123;
   intptr_t char_size;
   intptr_t str_len;
   Dart_Handle external_string = Dart_NewExternalLatin1String(
       data8, ARRAY_SIZE(data8), &external_peer_data, NULL);
   Dart_Handle internal_string = NewString("two");
 
   // Run benchmark.
   for (int64_t i = 0; i < kNumIterations; i++) {
     EXPECT(Dart_IsString(internal_string));
     EXPECT(!Dart_IsExternalString(internal_string));
     EXPECT_VALID(external_string);
     EXPECT(Dart_IsExternalString(external_string));
     void* external_peer = NULL;
-    EXPECT_VALID(Dart_StringGetProperties(external_string,
-                                          &char_size,
-                                          &str_len,
+    EXPECT_VALID(Dart_StringGetProperties(external_string, &char_size, &str_len,
                                           &external_peer));
     EXPECT_EQ(1, char_size);
     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);
+    script = OS::SCreate(NULL, "import '%s/pkg/compiler/lib/compiler.dart';",
+                         dart_root);
     Dart_Handle lib = TestCase::LoadTestScript(
-        script,
-        reinterpret_cast<Dart_NativeEntryResolver>(NativeResolver));
+        script, reinterpret_cast<Dart_NativeEntryResolver>(NativeResolver));
     EXPECT_VALID(lib);
   } else {
     Dart_Handle lib = TestCase::LoadTestScript(
         "import 'pkg/compiler/lib/compiler.dart';",
         reinterpret_cast<Dart_NativeEntryResolver>(NativeResolver));
     EXPECT_VALID(lib);
   }
   Timer timer(true, "Compile all of dart2js benchmark");
   timer.Start();
 #if !defined(PRODUCT)
@@ skipping 96 matching lines @@
   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) {
+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));
 }
 
 
 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"
       "\n";
 
   // Start an Isolate, load a script and create a full snapshot.
   uint8_t* vm_isolate_snapshot_buffer;
   uint8_t* isolate_snapshot_buffer;
   // Need to load the script into the dart: core library due to
   // the import of dart:_internal.
   TestCase::LoadCoreTestScript(kScriptChars, NULL);
   Api::CheckAndFinalizePendingClasses(thread);
 
   // Write snapshot with object content.
-  FullSnapshotWriter writer(Snapshot::kCore,
-                            &vm_isolate_snapshot_buffer,
-                            &isolate_snapshot_buffer,
-                            &malloc_allocator,
+  FullSnapshotWriter writer(Snapshot::kCore, &vm_isolate_snapshot_buffer,
+                            &isolate_snapshot_buffer, &malloc_allocator,
                             NULL /* instructions_writer */);
   writer.WriteFullSnapshot();
   const Snapshot* snapshot = Snapshot::SetupFromBuffer(isolate_snapshot_buffer);
   ASSERT(snapshot->kind() == Snapshot::kCore);
   benchmark->set_score(snapshot->length());
 }
 
 
 BENCHMARK_SIZE(StandaloneSnapshotSize) {
   const char* kScriptChars =
@@ skipping 12 matching lines @@
 
   // Start an Isolate, load a script and create a full snapshot.
   uint8_t* vm_isolate_snapshot_buffer;
   uint8_t* isolate_snapshot_buffer;
   // Need to load the script into the dart: core library due to
   // the import of dart:_internal.
   TestCase::LoadCoreTestScript(kScriptChars, NULL);
   Api::CheckAndFinalizePendingClasses(thread);
 
   // Write snapshot with object content.
-  FullSnapshotWriter writer(Snapshot::kCore,
-                            &vm_isolate_snapshot_buffer,
-                            &isolate_snapshot_buffer,
-                            &malloc_allocator,
+  FullSnapshotWriter writer(Snapshot::kCore, &vm_isolate_snapshot_buffer,
+                            &isolate_snapshot_buffer, &malloc_allocator,
                             NULL /* instructions_writer */);
   writer.WriteFullSnapshot();
   const Snapshot* snapshot = Snapshot::SetupFromBuffer(isolate_snapshot_buffer);
   ASSERT(snapshot->kind() == Snapshot::kCore);
   benchmark->set_score(snapshot->length());
 }
 
 
 BENCHMARK(CreateMirrorSystem) {
   const char* kScriptChars =
@@ skipping 28 matching lines @@
     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) {
+static uint8_t* message_allocator(uint8_t* ptr,
+                                  intptr_t old_size,
+                                  intptr_t new_size) {
   return message_buffer;
 }
 
 
 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, true);
     writer.WriteMessage(null_object);
     intptr_t buffer_len = writer.BytesWritten();
 
     // Read object back from the snapshot.
-    MessageSnapshotReader reader(buffer,
-                                 buffer_len,
-                                 thread);
+    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, true);
     writer.WriteMessage(smi_object);
     intptr_t buffer_len = writer.BytesWritten();
 
     // Read object back from the snapshot.
-    MessageSnapshotReader reader(buffer,
-                                 buffer_len,
-                                 thread);
+    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, true);
     writer.WriteMessage(array_object);
     intptr_t buffer_len = writer.BytesWritten();
 
     // Read object back from the snapshot.
-    MessageSnapshotReader reader(buffer,
-                                 buffer_len,
-                                 thread);
+    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) {
@@ skipping 13 matching lines @@
   uint8_t* buffer;
   Timer timer(true, "Large Map");
   timer.Start();
   for (intptr_t i = 0; i < kLoopCount; i++) {
     StackZone zone(thread);
     MessageWriter writer(&buffer, &malloc_allocator, true);
     writer.WriteMessage(map);
     intptr_t buffer_len = writer.BytesWritten();
 
     // Read object back from the snapshot.
-    MessageSnapshotReader reader(buffer,
-                                 buffer_len,
-                                 thread);
+    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