Move vm_tags from isolate to thread, since we may have multiple threads in same isolate (GC, backgr…

runtime/vm/profiler.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/address_sanitizer.h"
 #include "platform/memory_sanitizer.h"
 #include "platform/utils.h"
 
 #include "vm/allocation.h"
 #include "vm/atomic.h"
@@ skipping 147 matching lines @@
   }
   if (!FLAG_profile) {
     return;
   }
   ASSERT(initialized_);
   IsolateProfilerData* profiler_data = isolate->profiler_data();
   if (profiler_data == NULL) {
     return;
   }
   Thread* thread = Thread::Current();
-  thread->SetThreadInterrupter(RecordSampleInterruptCallback, isolate);
+  thread->SetThreadInterrupter(RecordSampleInterruptCallback, thread);
   ThreadInterrupter::WakeUp();
 }
 
 
 void Profiler::EndExecution(Isolate* isolate) {
   if (isolate == NULL) {
     return;
   }
   if (!FLAG_profile) {
     return;
@@ skipping 664 matching lines @@
                                   new_protect,
                                   &old_protect);
     USE(success);
     ASSERT(success);
     ASSERT(old_protect == PAGE_READWRITE);
   }
 #endif
 }
 
 
-// Is |isolate| executing Dart code?
-static bool ExecutingDart(Isolate* isolate) {
-  ASSERT(isolate != NULL);
-  return (isolate->top_exit_frame_info() == 0) &&
-         (isolate->vm_tag() == VMTag::kDartTagId);
+// Is |thread| executing Dart code?
+static bool ExecutingDart(Thread* thread) {
+  ASSERT(thread != NULL);
+  return (thread->top_exit_frame_info() == 0) &&
+         (thread->vm_tag() == VMTag::kDartTagId);
 }
 
 
-// Has |isolate| exited Dart code?
-static bool ExitedDart(Isolate* isolate) {
-  return (isolate->top_exit_frame_info() != 0) &&
-         (isolate->vm_tag() != VMTag::kDartTagId);
+// Has |thread| exited Dart code?
+static bool ExitedDart(Thread* thread) {
+  return (thread->top_exit_frame_info() != 0) &&
+         (thread->vm_tag() != VMTag::kDartTagId);
 }
 
 
 // Get |isolate|'s stack boundary and verify that |sp| and |fp| are within
 // it. Return |false| if anything looks suspicious.
-static bool GetAndValidateIsolateStackBounds(Isolate* isolate,
+static bool GetAndValidateIsolateStackBounds(Thread* thread,
                                              uintptr_t sp,
                                              uintptr_t fp,
                                              uword* stack_lower,
                                              uword* stack_upper) {
+  ASSERT(thread != NULL);
+  Isolate* isolate = thread->isolate();
   ASSERT(isolate != NULL);
   ASSERT(stack_lower != NULL);
   ASSERT(stack_upper != NULL);
 #if defined(USING_SIMULATOR)
-  const bool in_dart_code = ExecutingDart(isolate);
+  const bool in_dart_code = ExecutingDart(thread);
   if (in_dart_code) {
     Simulator* simulator = isolate->simulator();
     *stack_lower = simulator->StackBase();
     *stack_upper = simulator->StackTop();
   } else if (!isolate->GetProfilerStackBounds(stack_lower, stack_upper)) {
     // Could not get stack boundary.
     return false;
   }
   if ((*stack_lower == 0) || (*stack_upper == 0)) {
     return false;
@@ skipping 51 matching lines @@
   IsolateProfilerData* profiler_data = isolate->profiler_data();
   if (profiler_data == NULL) {
     // Profiler not initialized.
     return NULL;
   }
   SampleBuffer* sample_buffer = profiler_data->sample_buffer();
   return sample_buffer;
 }
 
 
-static Sample* SetupSample(Isolate* isolate,
+static Sample* SetupSample(Thread* thread,
                            SampleBuffer* sample_buffer,
                            ThreadId tid) {
-  ASSERT(isolate != NULL);
+  ASSERT(thread != NULL);
+  Isolate* isolate = thread->isolate();
   ASSERT(sample_buffer != NULL);
   Sample* sample = sample_buffer->ReserveSample();
   sample->Init(isolate, OS::GetCurrentTimeMicros(), tid);
-  uword vm_tag = isolate->vm_tag();
+  uword vm_tag = thread->vm_tag();
 #if defined(USING_SIMULATOR)
   // When running in the simulator, the runtime entry function address
   // (stored as the vm tag) is the address of a redirect function.
   // Attempt to find the real runtime entry function address and use that.
   uword redirect_vm_tag = Simulator::FunctionForRedirect(vm_tag);
   if (redirect_vm_tag != 0) {
     vm_tag = redirect_vm_tag;
   }
 #endif
   sample->set_vm_tag(vm_tag);
@@ skipping 17 matching lines @@
 static uintptr_t GetProgramCounter() {
   return reinterpret_cast<uintptr_t>(_ReturnAddress());
 }
 #else
 static uintptr_t __attribute__((noinline)) GetProgramCounter() {
   return reinterpret_cast<uintptr_t>(
       __builtin_extract_return_addr(__builtin_return_address(0)));
 }
 #endif
 
-void Profiler::RecordAllocation(Isolate* isolate, intptr_t cid) {
+void Profiler::RecordAllocation(Thread* thread, intptr_t cid) {
+  ASSERT(thread != NULL);
+  Isolate* isolate = thread->isolate();
   if (!CheckIsolate(isolate)) {
     return;
   }
 
-  const bool exited_dart_code = ExitedDart(isolate);
+  const bool exited_dart_code = ExitedDart(thread);
 
   SampleBuffer* sample_buffer = GetSampleBuffer(isolate);
   if (sample_buffer == NULL) {
     // Profiler not initialized.
     return;
   }
 
   if (FLAG_profile_vm) {
     uintptr_t sp = Isolate::GetCurrentStackPointer();
     uintptr_t fp = 0;
     uintptr_t pc = GetProgramCounter();
 
     COPY_FP_REGISTER(fp);
 
     uword stack_lower = 0;
     uword stack_upper = 0;
 
     if (!InitialRegisterCheck(pc, sp, fp)) {
       return;
     }
 
-    if (!GetAndValidateIsolateStackBounds(isolate,
+    if (!GetAndValidateIsolateStackBounds(thread,
                                           sp,
                                           fp,
                                           &stack_lower,
                                           &stack_upper)) {
       // Could not get stack boundary.
       return;
     }
 
-    Sample* sample = SetupSample(isolate,
+    Sample* sample = SetupSample(thread,
                                  sample_buffer,
                                  OSThread::GetCurrentThreadId());
     sample->SetAllocationCid(cid);
     ProfilerNativeStackWalker native_stack_walker(isolate,
                                                   sample,
                                                   sample_buffer,
                                                   stack_lower,
                                                   stack_upper,
                                                   pc,
                                                   fp,
                                                   sp);
     native_stack_walker.walk();
   } else if (exited_dart_code) {
-    Sample* sample = SetupSample(isolate,
+    Sample* sample = SetupSample(thread,
                                  sample_buffer,
                                  OSThread::GetCurrentThreadId());
     sample->SetAllocationCid(cid);
     ProfilerDartExitStackWalker dart_exit_stack_walker(isolate,
                                                        sample,
                                                        sample_buffer);
     dart_exit_stack_walker.walk();
   } else {
     // Fall back.
     uintptr_t pc = GetProgramCounter();
-    Sample* sample = SetupSample(isolate,
+    Sample* sample = SetupSample(thread,
                                  sample_buffer,
                                  OSThread::GetCurrentThreadId());
     sample->SetAllocationCid(cid);
     sample->set_vm_tag(VMTag::kEmbedderTagId);
     sample->SetAt(0, pc);
   }
 }
 
 
 void Profiler::RecordSampleInterruptCallback(
     const InterruptedThreadState& state,
     void* data) {
-  Isolate* isolate = reinterpret_cast<Isolate*>(data);
+  Thread* thread = reinterpret_cast<Thread*>(data);
+  Isolate* isolate = thread->isolate();
   if ((isolate == NULL) || (Dart::vm_isolate() == NULL)) {
     // No isolate.
     return;
   }
   ASSERT(isolate != Dart::vm_isolate());
 
   SampleBuffer* sample_buffer = GetSampleBuffer(isolate);
   if (sample_buffer == NULL) {
     // Profiler not initialized.
     return;
   }
 
-  const bool exited_dart_code = ExitedDart(isolate);
-  const bool in_dart_code = ExecutingDart(isolate);
+  const bool exited_dart_code = ExitedDart(thread);
+  const bool in_dart_code = ExecutingDart(thread);
 
   uintptr_t sp = 0;
   uintptr_t fp = state.fp;
   uintptr_t pc = state.pc;
 #if defined(USING_SIMULATOR)
   Simulator* simulator = NULL;
 #endif
 
   if (in_dart_code) {
     // If we're in Dart code, use the Dart stack pointer.
@@ skipping 16 matching lines @@
 
   if (StubCode::InJumpToExceptionHandlerStub(pc)) {
     // The JumpToExceptionHandler stub manually adjusts the stack pointer,
     // frame pointer, and some isolate state before jumping to a catch entry.
     // It is not safe to walk the stack when executing this stub.
     return;
   }
 
   uword stack_lower = 0;
   uword stack_upper = 0;
-  if (!GetAndValidateIsolateStackBounds(isolate,
+  if (!GetAndValidateIsolateStackBounds(thread,
                                         sp,
                                         fp,
                                         &stack_lower,
                                         &stack_upper)) {
     // Could not get stack boundary.
     return;
   }
 
   // At this point we have a valid stack boundary for this isolate and
   // know that our initial stack and frame pointers are within the boundary.
 
   // Setup sample.
-  Sample* sample = SetupSample(isolate,
+  Sample* sample = SetupSample(thread,
                                sample_buffer,
                                OSThread::GetCurrentThreadId());
   // Increment counter for vm tag.
   VMTagCounters* counters = isolate->vm_tag_counters();
   ASSERT(counters != NULL);
   counters->Increment(sample->vm_tag());
 
   ProfilerNativeStackWalker native_stack_walker(isolate,
                                                 sample,
                                                 sample_buffer,
@@ skipping 240 matching lines @@
                                                uword pc) {
   return vm_isolate->heap()->CodeContains(pc)
          || isolate->heap()->CodeContains(pc);
 }
 
 
 ProcessedSampleBuffer::ProcessedSampleBuffer() {
 }
 
 }  // namespace dart