clang-format runtime/vm

runtime/vm/profiler_test.cc

 // Copyright (c) 2013, 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 "platform/assert.h"
 
 #include "vm/dart_api_impl.h"
 #include "vm/dart_api_state.h"
 #include "vm/globals.h"
 #include "vm/profiler.h"
 #include "vm/profiler_service.h"
 #include "vm/source_report.h"
 #include "vm/unit_test.h"
 
 namespace dart {
 
 #ifndef PRODUCT
 
 DECLARE_FLAG(bool, profile_vm);
 DECLARE_FLAG(int, max_profile_depth);
 DECLARE_FLAG(bool, enable_inlining_annotations);
 DECLARE_FLAG(int, optimization_counter_threshold);
 
 // Some tests are written assuming native stack trace profiling is disabled.
 class DisableNativeProfileScope : public ValueObject {
  public:
-  DisableNativeProfileScope()
-      : FLAG_profile_vm_(FLAG_profile_vm) {
+  DisableNativeProfileScope() : FLAG_profile_vm_(FLAG_profile_vm) {
     FLAG_profile_vm = false;
   }
 
-  ~DisableNativeProfileScope() {
-    FLAG_profile_vm = FLAG_profile_vm_;
-  }
+  ~DisableNativeProfileScope() { FLAG_profile_vm = FLAG_profile_vm_; }
 
  private:
   const bool FLAG_profile_vm_;
 };
 
 
 class DisableBackgroundCompilationScope : public ValueObject {
  public:
   DisableBackgroundCompilationScope()
       : FLAG_background_compilation_(FLAG_background_compilation) {
@@ skipping 10 matching lines @@
 
 
 // Temporarily adjust the maximum profile depth.
 class MaxProfileDepthScope : public ValueObject {
  public:
   explicit MaxProfileDepthScope(intptr_t new_max_depth)
       : FLAG_max_profile_depth_(FLAG_max_profile_depth) {
     Profiler::SetSampleDepth(new_max_depth);
   }
 
-  ~MaxProfileDepthScope() {
-    Profiler::SetSampleDepth(FLAG_max_profile_depth_);
-  }
+  ~MaxProfileDepthScope() { Profiler::SetSampleDepth(FLAG_max_profile_depth_); }
 
  private:
   const intptr_t FLAG_max_profile_depth_;
 };
 
 
 class ProfileSampleBufferTestHelper {
  public:
   static intptr_t IterateCount(const Isolate* isolate,
                                const SampleBuffer& sample_buffer) {
@@ skipping 76 matching lines @@
   Sample* sample = sample_buffer->ReserveSample();
   sample->Init(isolate, 0, 0);
   sample->set_metadata(99);
   sample->set_is_allocation_sample(true);
   EXPECT_EQ(99, sample->allocation_cid());
   delete sample_buffer;
 }
 
 
 static RawClass* GetClass(const Library& lib, const char* name) {
-  const Class& cls = Class::Handle(
-      lib.LookupClassAllowPrivate(String::Handle(Symbols::New(Thread::Current(),
-                                                              name))));
+  const Class& cls = Class::Handle(lib.LookupClassAllowPrivate(
+      String::Handle(Symbols::New(Thread::Current(), name))));
   EXPECT(!cls.IsNull());  // No ambiguity error expected.
   return cls.raw();
 }
 
 
 static RawFunction* GetFunction(const Library& lib, const char* name) {
   const Function& func = Function::Handle(lib.LookupFunctionAllowPrivate(
       String::Handle(Symbols::New(Thread::Current(), name))));
   EXPECT(!func.IsNull());  // No ambiguity error expected.
   return func.raw();
 }
 
 
 class AllocationFilter : public SampleFilter {
  public:
   AllocationFilter(Isolate* isolate,
                    intptr_t cid,
                    int64_t time_origin_micros = -1,
                    int64_t time_extent_micros = -1)
       : SampleFilter(isolate,
                      Thread::kMutatorTask,
                      time_origin_micros,
                      time_extent_micros),
         cid_(cid),
-        enable_vm_ticks_(false) {
-  }
+        enable_vm_ticks_(false) {}
 
   bool FilterSample(Sample* sample) {
-    if (!enable_vm_ticks_ &&
-        (sample->vm_tag() == VMTag::kVMTagId)) {
+    if (!enable_vm_ticks_ && (sample->vm_tag() == VMTag::kVMTagId)) {
       // We don't want to see embedder ticks in the test.
       return false;
     }
-    return sample->is_allocation_sample() &&
-           (sample->allocation_cid() == cid_);
+    return sample->is_allocation_sample() && (sample->allocation_cid() == cid_);
   }
 
-  void set_enable_vm_ticks(bool enable) {
-    enable_vm_ticks_ = enable;
-  }
+  void set_enable_vm_ticks(bool enable) { enable_vm_ticks_ = enable; }
 
  private:
   intptr_t cid_;
   bool enable_vm_ticks_;
 };
 
 
 TEST_CASE(Profiler_TrivialRecordAllocation) {
   DisableNativeProfileScope dnps;
   const char* kScript =
@@ skipping 26 matching lines @@
   const int64_t after_allocations_micros = Dart_TimelineGetMicros();
   const int64_t allocation_extent_micros =
       after_allocations_micros - before_allocations_micros;
   {
     Thread* thread = Thread::Current();
     Isolate* isolate = thread->isolate();
     StackZone zone(thread);
     HANDLESCOPE(thread);
     Profile profile(isolate);
     // Filter for the class in the time range.
-    AllocationFilter filter(isolate,
-                            class_a.id(),
-                            before_allocations_micros,
+    AllocationFilter filter(isolate, class_a.id(), before_allocations_micros,
                             allocation_extent_micros);
     profile.Build(thread, &filter, Profile::kNoTags);
     // We should have 1 allocation sample.
     EXPECT_EQ(1, profile.sample_count());
     ProfileTrieWalker walker(&profile);
 
     // Exclusive code: B.boo -> main.
     walker.Reset(Profile::kExclusiveCode);
     // Move down from the root.
     EXPECT(walker.Down());
@@ skipping 38 matching lines @@
     EXPECT(!walker.Down());
   }
 
   // Query with a time filter where no allocations occurred.
   {
     Thread* thread = Thread::Current();
     Isolate* isolate = thread->isolate();
     StackZone zone(thread);
     HANDLESCOPE(thread);
     Profile profile(isolate);
-    AllocationFilter filter(isolate,
-                            class_a.id(),
-                            Dart_TimelineGetMicros(),
+    AllocationFilter filter(isolate, class_a.id(), Dart_TimelineGetMicros(),
                             16000);
     profile.Build(thread, &filter, Profile::kNoTags);
     // We should have no allocation samples because none occured within
     // the specified time range.
     EXPECT_EQ(0, profile.sample_count());
   }
 }
 
 
 TEST_CASE(Profiler_ToggleRecordAllocation) {
@@ skipping 323 matching lines @@
   Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib);
   Library& root_library = Library::Handle();
   root_library ^= Api::UnwrapHandle(lib);
   Isolate* isolate = thread->isolate();
 
   const Class& double_class =
       Class::Handle(isolate->object_store()->double_class());
   EXPECT(!double_class.IsNull());
 
-  Dart_Handle args[2] = { Dart_NewDouble(1.0), Dart_NewDouble(2.0), };
+  Dart_Handle args[2] = {
+      Dart_NewDouble(1.0), Dart_NewDouble(2.0),
+  };
 
   Dart_Handle result = Dart_Invoke(lib, NewString("foo"), 2, &args[0]);
   EXPECT_VALID(result);
 
   {
     StackZone zone(thread);
     HANDLESCOPE(thread);
     Profile profile(isolate);
     AllocationFilter filter(isolate, double_class.id());
     profile.Build(thread, &filter, Profile::kNoTags);
@@ skipping 158 matching lines @@
       "foo() {\n"
       "  var msg = msg1 + msg1;\n"
       "  return (x) { return '$msg + $msg'; }(msg);\n"
       "}\n";
   Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib);
   Library& root_library = Library::Handle();
   root_library ^= Api::UnwrapHandle(lib);
   Isolate* isolate = thread->isolate();
 
-  const Class& context_class =
-      Class::Handle(Object::context_class());
+  const Class& context_class = Class::Handle(Object::context_class());
   EXPECT(!context_class.IsNull());
 
   Dart_Handle result = Dart_Invoke(lib, NewString("foo"), 0, NULL);
   EXPECT_VALID(result);
 
   {
     StackZone zone(thread);
     HANDLESCOPE(thread);
     Profile profile(isolate);
     AllocationFilter filter(isolate, context_class.id());
@@ skipping 201 matching lines @@
   Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib);
   Library& root_library = Library::Handle();
   root_library ^= Api::UnwrapHandle(lib);
   Isolate* isolate = thread->isolate();
 
   const Class& one_byte_string_class =
       Class::Handle(isolate->object_store()->one_byte_string_class());
   EXPECT(!one_byte_string_class.IsNull());
 
-  Dart_Handle args[2] = { NewString("a"), NewString("b"), };
+  Dart_Handle args[2] = {
+      NewString("a"), NewString("b"),
+  };
 
   Dart_Handle result = Dart_Invoke(lib, NewString("foo"), 2, &args[0]);
   EXPECT_VALID(result);
 
   {
     StackZone zone(thread);
     HANDLESCOPE(thread);
     Profile profile(isolate);
     AllocationFilter filter(isolate, one_byte_string_class.id());
     profile.Build(thread, &filter, Profile::kNoTags);
@@ skipping 62 matching lines @@
   Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib);
   Library& root_library = Library::Handle();
   root_library ^= Api::UnwrapHandle(lib);
   Isolate* isolate = thread->isolate();
 
   const Class& one_byte_string_class =
       Class::Handle(isolate->object_store()->one_byte_string_class());
   EXPECT(!one_byte_string_class.IsNull());
 
-  Dart_Handle args[2] = { NewString("a"), NewString("b"), };
+  Dart_Handle args[2] = {
+      NewString("a"), NewString("b"),
+  };
 
   Dart_Handle result = Dart_Invoke(lib, NewString("foo"), 2, &args[0]);
   EXPECT_VALID(result);
 
   {
     StackZone zone(thread);
     HANDLESCOPE(thread);
     Profile profile(isolate);
     AllocationFilter filter(isolate, one_byte_string_class.id());
     profile.Build(thread, &filter, Profile::kNoTags);
@@ skipping 234 matching lines @@
   }
 
   // Test code transition tags.
   {
     Thread* thread = Thread::Current();
     Isolate* isolate = thread->isolate();
     StackZone zone(thread);
     HANDLESCOPE(thread);
     Profile profile(isolate);
     AllocationFilter filter(isolate, class_a.id());
-    profile.Build(thread,
-                  &filter,
-                  Profile::kNoTags,
+    profile.Build(thread, &filter, Profile::kNoTags,
                   ProfilerService::kCodeTransitionTagsBit);
     // We should have 50,000 allocation samples.
     EXPECT_EQ(50000, profile.sample_count());
     ProfileTrieWalker walker(&profile);
     // We have two code objects: mainA and B.boo.
     walker.Reset(Profile::kExclusiveCode);
     EXPECT(walker.Down());
     EXPECT_STREQ("DRT_AllocateObject", walker.CurrentName());
     EXPECT(walker.Down());
     EXPECT_STREQ("B.boo", walker.CurrentName());
@@ skipping 938 matching lines @@
     EXPECT_STREQ("main", walker.CurrentName());
     EXPECT_EQ(1, walker.CurrentNodeTickCount());
     EXPECT_EQ(1, walker.CurrentInclusiveTicks());
     EXPECT_EQ(0, walker.CurrentExclusiveTicks());
     EXPECT_STREQ("bacon", walker.CurrentToken());
     EXPECT(!walker.Down());
   }
 }
 
 
-static void InsertFakeSample(SampleBuffer* sample_buffer,
-                             uword* pc_offsets) {
+static void InsertFakeSample(SampleBuffer* sample_buffer, uword* pc_offsets) {
   ASSERT(sample_buffer != NULL);
   Isolate* isolate = Isolate::Current();
   Sample* sample = sample_buffer->ReserveSample();
   ASSERT(sample != NULL);
-  sample->Init(isolate,
-               OS::GetCurrentMonotonicMicros(),
+  sample->Init(isolate, OS::GetCurrentMonotonicMicros(),
                OSThread::Current()->trace_id());
   sample->set_thread_task(Thread::kMutatorTask);
 
   intptr_t i = 0;
   while (pc_offsets[i] != 0) {
     // When we collect a real stack trace, all PCs collected aside from the
     // executing one (i == 0) are actually return addresses. Return addresses
     // are one byte beyond the call instruction that is executing. The profiler
     // accounts for this and subtracts one from these addresses when querying
     // inline and token position ranges. To be consistent with real stack
@@ skipping 87 matching lines @@
 
   const CodeSourceMap& do_work_code_source_map =
       CodeSourceMap::Handle(do_work_code.code_source_map());
   EXPECT(!do_work_code_source_map.IsNull());
 
   // Dump code source map.
   CodeSourceMap::Dump(do_work_code_source_map, do_work_code, main);
   CodeSourceMap::Dump(main_code_source_map, main_code, main);
 
   // Look up some source token position's pc.
-  uword squarePositionPc =
-      FindPCForTokenPosition(do_work_code,
-                             do_work_code_source_map,
-                             squarePosition);
+  uword squarePositionPc = FindPCForTokenPosition(
+      do_work_code, do_work_code_source_map, squarePosition);
   EXPECT(squarePositionPc != 0);
 
   uword callPositionPc =
       FindPCForTokenPosition(main_code, main_code_source_map, callPosition);
   EXPECT(callPositionPc != 0);
 
   // Look up some classifying token position's pc.
-  uword controlFlowPc =
-      FindPCForTokenPosition(do_work_code,
-                             do_work_code_source_map,
-                             TokenPosition::kControlFlow);
+  uword controlFlowPc = FindPCForTokenPosition(
+      do_work_code, do_work_code_source_map, TokenPosition::kControlFlow);
   EXPECT(controlFlowPc != 0);
 
-  uword tempMovePc =
-      FindPCForTokenPosition(main_code,
-                             main_code_source_map,
-                             TokenPosition::kTempMove);
+  uword tempMovePc = FindPCForTokenPosition(main_code, main_code_source_map,
+                                            TokenPosition::kTempMove);
   EXPECT(tempMovePc != 0);
 
   // Insert fake samples.
 
   // Sample 1:
   // squarePositionPc exclusive.
   // callPositionPc inclusive.
-  uword sample1[] = {
-    squarePositionPc,  // doWork.
-    callPositionPc,    // main.
-    0
-  };
+  uword sample1[] = {squarePositionPc,  // doWork.
+                     callPositionPc,    // main.
+                     0};
 
   // Sample 2:
   // squarePositionPc exclusive.
   uword sample2[] = {
-    squarePositionPc,  // doWork.
-    0,
+      squarePositionPc,  // doWork.
+      0,
   };
 
   // Sample 3:
   // controlFlowPc exclusive.
   // callPositionPc inclusive.
-  uword sample3[] = {
-    controlFlowPc,   // doWork.
-    callPositionPc,  // main.
-    0
-  };
+  uword sample3[] = {controlFlowPc,   // doWork.
+                     callPositionPc,  // main.
+                     0};
 
   // Sample 4:
   // tempMovePc exclusive.
-  uword sample4[] = {
-    tempMovePc,  // main.
-    0
-  };
+  uword sample4[] = {tempMovePc,  // main.
+                     0};
 
   InsertFakeSample(sample_buffer, &sample1[0]);
   InsertFakeSample(sample_buffer, &sample2[0]);
   InsertFakeSample(sample_buffer, &sample3[0]);
   InsertFakeSample(sample_buffer, &sample4[0]);
 
   // Generate source report for main.
   SourceReport sourceReport(SourceReport::kProfile);
   JSONStream js;
-  sourceReport.PrintJSON(&js,
-                         script,
-                         do_work.token_pos(),
+  sourceReport.PrintJSON(&js, script, do_work.token_pos(),
                          main.end_token_pos());
 
   // Verify positions in do_work.
   EXPECT_SUBSTRING("\"positions\":[\"ControlFlow\",6]", js.ToCString());
   // Verify exclusive ticks in do_work.
   EXPECT_SUBSTRING("\"exclusiveTicks\":[1,2]", js.ToCString());
   // Verify inclusive ticks in do_work.
   EXPECT_SUBSTRING("\"inclusiveTicks\":[1,2]", js.ToCString());
 
   // Verify positions in main.
   EXPECT_SUBSTRING("\"positions\":[\"TempMove\",39]", js.ToCString());
   // Verify exclusive ticks in main.
   EXPECT_SUBSTRING("\"exclusiveTicks\":[1,0]", js.ToCString());
   // Verify inclusive ticks in main.
   EXPECT_SUBSTRING("\"inclusiveTicks\":[1,2]", js.ToCString());
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart