Revert "Switch profiler from isolates to threads"

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"
 #include "vm/code_patcher.h"
-#include "vm/debugger.h"
 #include "vm/instructions.h"
 #include "vm/isolate.h"
 #include "vm/json_stream.h"
 #include "vm/lockers.h"
-#include "vm/message_handler.h"
 #include "vm/native_symbol.h"
 #include "vm/object.h"
 #include "vm/os.h"
 #include "vm/profiler.h"
 #include "vm/reusable_handles.h"
 #include "vm/signal_handler.h"
 #include "vm/simulator.h"
 #include "vm/stack_frame.h"
 
 namespace dart {
@@ skipping 71 matching lines @@
 void Profiler::SetSamplePeriod(intptr_t period) {
   const int kMinimumProfilePeriod = 50;
   if (period < kMinimumProfilePeriod) {
     FLAG_profile_period = kMinimumProfilePeriod;
   } else {
     FLAG_profile_period = period;
   }
 }
 
 
+void Profiler::InitProfilingForIsolate(Isolate* isolate, bool shared_buffer) {
+  if (!FLAG_profile) {
+    return;
+  }
+  ASSERT(isolate == Isolate::Current());
+  ASSERT(isolate != NULL);
+  ASSERT(sample_buffer_ != NULL);
+  {
+    MutexLocker profiler_data_lock(isolate->profiler_data_mutex());
+    SampleBuffer* sample_buffer = sample_buffer_;
+    if (!shared_buffer) {
+      sample_buffer = new SampleBuffer();
+    }
+    IsolateProfilerData* profiler_data =
+        new IsolateProfilerData(sample_buffer, !shared_buffer);
+    ASSERT(profiler_data != NULL);
+    isolate->set_profiler_data(profiler_data);
+    if (FLAG_trace_profiled_isolates) {
+      OS::Print("Profiler Setup %p %s\n", isolate, isolate->name());
+    }
+  }
+  BeginExecution(isolate);
+}
+
+
+void Profiler::ShutdownProfilingForIsolate(Isolate* isolate) {
+  ASSERT(isolate != NULL);
+  if (!FLAG_profile) {
+    return;
+  }
+  // We do not have a current isolate.
+  ASSERT(Isolate::Current() == NULL);
+  {
+    MutexLocker profiler_data_lock(isolate->profiler_data_mutex());
+    IsolateProfilerData* profiler_data = isolate->profiler_data();
+    if (profiler_data == NULL) {
+      // Already freed.
+      return;
+    }
+    isolate->set_profiler_data(NULL);
+    delete profiler_data;
+    if (FLAG_trace_profiled_isolates) {
+      OS::Print("Profiler Shutdown %p %s\n", isolate, isolate->name());
+    }
+  }
+}
+
+
+void Profiler::BeginExecution(Isolate* isolate) {
+  if (isolate == NULL) {
+    return;
+  }
+  if (!FLAG_profile) {
+    return;
+  }
+  ASSERT(initialized_);
+  IsolateProfilerData* profiler_data = isolate->profiler_data();
+  if (profiler_data == NULL) {
+    return;
+  }
+  Thread* thread = Thread::Current();
+  thread->SetThreadInterrupter(RecordSampleInterruptCallback, thread);
+  ThreadInterrupter::WakeUp();
+}
+
+
+void Profiler::EndExecution(Isolate* isolate) {
+  if (isolate == NULL) {
+    return;
+  }
+  if (!FLAG_profile) {
+    return;
+  }
+  ASSERT(initialized_);
+  Thread* thread = Thread::Current();
+  thread->SetThreadInterrupter(NULL, NULL);
+}
+
+
+IsolateProfilerData::IsolateProfilerData(SampleBuffer* sample_buffer,
+                                         bool own_sample_buffer) {
+  ASSERT(sample_buffer != NULL);
+  sample_buffer_ = sample_buffer;
+  own_sample_buffer_ = own_sample_buffer;
+  block_count_ = 0;
+}
+
+
+IsolateProfilerData::~IsolateProfilerData() {
+  if (own_sample_buffer_) {
+    delete sample_buffer_;
+    sample_buffer_ = NULL;
+    own_sample_buffer_ = false;
+  }
+}
+
+
+void IsolateProfilerData::Block() {
+  block_count_++;
+}
+
+
+void IsolateProfilerData::Unblock() {
+  block_count_--;
+  if (block_count_ < 0) {
+    FATAL("Too many calls to Dart_IsolateUnblocked.");
+  }
+  if (!blocked()) {
+    // We just unblocked this isolate, wake up the thread interrupter.
+    ThreadInterrupter::WakeUp();
+  }
+}
+
+
 intptr_t Sample::pcs_length_ = 0;
 intptr_t Sample::instance_size_ = 0;
 
 
 void Sample::InitOnce() {
   pcs_length_ = kSampleSize;
   instance_size_ =
       sizeof(Sample) + (sizeof(uword) * pcs_length_);  // NOLINT.
 }
 
@@ skipping 579 matching lines @@
 
   if (in_dart_code) {
     // We can only trust the stack pointer if we are executing Dart code.
     // See http://dartbug.com/20421 for details.
     CopyStackBuffer(sample, sp);
   }
 
   if (FLAG_profile_vm) {
     // Always walk the native stack collecting both native and Dart frames.
     native_stack_walker->walk();
-  } else if (StubCode::HasBeenInitialized() && exited_dart_code) {
+  } else if (exited_dart_code) {
     // We have a valid exit frame info, use the Dart stack walker.
     dart_exit_stack_walker->walk();
-  } else if (StubCode::HasBeenInitialized() && in_dart_code) {
+  } else if (in_dart_code) {
     // We are executing Dart code. We have frame pointers.
     dart_stack_walker->walk();
   } else {
     sample->set_vm_tag(VMTag::kEmbedderTagId);
     sample->SetAt(0, pc);
   }
 
 #if defined(TARGET_OS_WINDOWS)
   // Use structured exception handling to trap guard page access.
   } __except(GuardPageExceptionFilter(GetExceptionInformation())) {
@@ skipping 10 matching lines @@
                                   new_protect,
                                   &old_protect);
     USE(success);
     ASSERT(success);
     ASSERT(old_protect == PAGE_READWRITE);
   }
 #endif
 }
 
 
+// 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 |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(Thread* thread,
+                                             uintptr_t sp,
                                              uintptr_t fp,
-                                             uintptr_t sp,
                                              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 = thread->IsExecutingDartCode();
+  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 22 matching lines @@
 
   if ((fp < *stack_lower) || (fp >= *stack_upper)) {
     // Frame pointer is outside isolate stack boundary.
     return false;
   }
 
   return true;
 }
 
 
-// Some simple sanity checking of |pc|, |fp|, and |sp|.
-static bool InitialRegisterCheck(uintptr_t pc, uintptr_t fp, uintptr_t sp) {
+// Some simple sanity checking of |pc|, |sp|, and |fp|.
+static bool InitialRegisterCheck(uintptr_t pc, uintptr_t sp, uintptr_t fp) {
   if ((sp == 0) || (fp == 0) || (pc == 0)) {
     // None of these registers should be zero.
     return false;
   }
 
   if (sp > fp) {
     // Assuming the stack grows down, we should never have a stack pointer above
     // the frame pointer.
     return false;
   }
 
   return true;
 }
 
 
+// Return |isolate|'s sample buffer.
+static SampleBuffer* GetSampleBuffer(Isolate* isolate) {
+  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(Thread* thread,
                            SampleBuffer* sample_buffer,
                            ThreadId tid) {
   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 = 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);
   sample->set_user_tag(isolate->user_tag());
   return sample;
 }
 
 
 static bool CheckIsolate(Isolate* isolate) {
   if ((isolate == NULL) || (Dart::vm_isolate() == NULL)) {
     // No isolate.
     return false;
   }
-  return isolate != Dart::vm_isolate();
+  ASSERT(isolate != Dart::vm_isolate());
+  return true;
 }
 
 
 #if defined(TARGET_OS_WINDOWS)
 __declspec(noinline)
 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::SampleAllocation(Thread* thread, 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 = thread->HasExitedDartCode();
+  const bool exited_dart_code = ExitedDart(thread);
 
-  SampleBuffer* sample_buffer = Profiler::sample_buffer();
+  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, fp, sp)) {
+    if (!InitialRegisterCheck(pc, sp, fp)) {
       return;
     }
 
     if (!GetAndValidateIsolateStackBounds(thread,
+                                          sp,
                                           fp,
-                                          sp,
                                           &stack_lower,
                                           &stack_upper)) {
       // Could not get stack boundary.
       return;
     }
 
     Sample* sample = SetupSample(thread,
                                  sample_buffer,
                                  OSThread::GetCurrentThreadId());
     sample->SetAllocationCid(cid);
@@ skipping 22 matching lines @@
     Sample* sample = SetupSample(thread,
                                  sample_buffer,
                                  OSThread::GetCurrentThreadId());
     sample->SetAllocationCid(cid);
     sample->set_vm_tag(VMTag::kEmbedderTagId);
     sample->SetAt(0, pc);
   }
 }
 
 
-void Profiler::SampleThread(Thread* thread,
-                            const InterruptedThreadState& state) {
-  if (StubCode::HasBeenInitialized() &&
-      StubCode::InJumpToExceptionHandlerStub(state.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.
+void Profiler::RecordSampleInterruptCallback(
+    const InterruptedThreadState& state,
+    void* 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 in_dart_code = thread->IsExecutingDartCode();
+  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
 
-  ASSERT(thread != NULL);
-  Isolate* isolate = thread->isolate();
-
   if (in_dart_code) {
     // If we're in Dart code, use the Dart stack pointer.
 #if defined(USING_SIMULATOR)
     simulator = isolate->simulator();
     sp = simulator->get_register(SPREG);
     fp = simulator->get_register(FPREG);
     pc = simulator->get_pc();
 #else
     sp = state.dsp;
 #endif
   } else {
     // If we're in runtime code, use the C stack pointer.
     sp = state.csp;
   }
 
-  if (!InitialRegisterCheck(pc, fp, sp)) {
+  if (!InitialRegisterCheck(pc, sp, fp)) {
     return;
   }
 
-  if (!CheckIsolate(isolate)) {
-    return;
-  }
-
-  if (!thread->IsMutatorThread()) {
-    // Not a mutator thread.
-    // TODO(johnmccutchan): Profile all threads with an isolate.
+  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(thread,
+                                        sp,
                                         fp,
-                                        sp,
                                         &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.
-  SampleBuffer* sample_buffer = Profiler::sample_buffer();
-  if (sample_buffer == NULL) {
-    // Profiler not initialized.
-    return;
-  }
 
   // Setup sample.
   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());
 
@@ skipping 13 matching lines @@
 
   ProfilerDartStackWalker dart_stack_walker(isolate,
                                             sample,
                                             sample_buffer,
                                             stack_lower,
                                             stack_upper,
                                             pc,
                                             fp,
                                             sp);
 
-  const bool exited_dart_code = thread->HasExitedDartCode();
-
   // All memory access is done inside CollectSample.
   CollectSample(isolate,
                 exited_dart_code,
                 in_dart_code,
                 sample,
                 &native_stack_walker,
                 &dart_exit_stack_walker,
                 &dart_stack_walker,
                 pc,
                 fp,
@@ skipping 211 matching lines @@
                                                uword pc) {
   return vm_isolate->heap()->CodeContains(pc)
          || isolate->heap()->CodeContains(pc);
 }
 
 
 ProcessedSampleBuffer::ProcessedSampleBuffer() {
 }
 
 }  // namespace dart