Profiling fixes

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 <cstdio>
 
 #include "platform/utils.h"
 
 #include "vm/isolate.h"
 #include "vm/json_stream.h"
@@ skipping 85 matching lines @@
 void ProfilerManager::Shutdown() {
   if (!FLAG_profile) {
     return;
   }
   ASSERT(initialized_);
   {
     ScopedSignalBlocker ssb;
     {
       ScopedMonitor lock(monitor_);
       shutdown_ = true;
-      for (intptr_t i = 0; i < isolates_size_; i++) {
-        Isolate* isolate = isolates_[i];
-        ASSERT(isolate != NULL);
-        FreeIsolateProfilingData(isolate);
-      }
       isolates_size_ = 0;
       free(isolates_);
       isolates_ = NULL;
       lock.Notify();
     }
   }
   NativeSymbolResolver::ShutdownOnce();
 }
 
 
@@ skipping 52 matching lines @@
   }
 }
 
 
 void ProfilerManager::ScheduleIsolate(Isolate* isolate, bool inside_signal) {
   if (!FLAG_profile) {
     return;
   }
   ASSERT(initialized_);
   ASSERT(isolate != NULL);
-  {
+  if (!inside_signal) {
     ScopedSignalBlocker ssb;
     {
       ScopedMonitor lock(monitor_);
       {
         ScopedMutex profiler_data_lock(isolate->profiler_data_mutex());
         IsolateProfilerData* profiler_data = isolate->profiler_data();
         if (profiler_data == NULL) {
           return;
         }
         profiler_data->Scheduled(OS::GetCurrentTimeMicros(),
                                  Thread::GetCurrentThreadId());
-        AddIsolate(isolate);
-        lock.Notify();
       }
+      AddIsolate(isolate);
+      lock.Notify();
+    }
+  } else {
+    // Do not need a signal blocker inside a signal handler.
+    {
+      ScopedMonitor lock(monitor_);
+      {
+        ScopedMutex profiler_data_lock(isolate->profiler_data_mutex());
+        IsolateProfilerData* profiler_data = isolate->profiler_data();
+        if (profiler_data == NULL) {
+          return;
+        }
+        profiler_data->Scheduled(OS::GetCurrentTimeMicros(),
+                                 Thread::GetCurrentThreadId());
+      }
+      AddIsolate(isolate);
+      lock.Notify();
     }
   }
 }
 
 
 void ProfilerManager::DescheduleIsolate(Isolate* isolate) {
   if (!FLAG_profile) {
     return;
   }
   ASSERT(initialized_);
@@ skipping 49 matching lines @@
   if (isolates_size_ == isolates_capacity_) {
     ResizeIsolates(isolates_capacity_ == 0 ? 16 : isolates_capacity_ * 2);
   }
   isolates_[isolates_size_] = isolate;
   isolates_size_++;
 }
 
 
 intptr_t ProfilerManager::FindIsolate(Isolate* isolate) {
   // Must be called with monitor_ locked.
+  if (isolates_ == NULL) {
+    // We are shutting down.
+    return -1;
+  }
   for (intptr_t i = 0; i < isolates_size_; i++) {
     if (isolates_[i] == isolate) {
       return i;
     }
   }
   return -1;
 }
 
 
 void ProfilerManager::RemoveIsolate(intptr_t i) {
   // Must be called with monitor_ locked.
+  if (isolates_ == NULL) {
+    // We are shutting down.
+    return;
+  }
   ASSERT(i < isolates_size_);
   intptr_t last = isolates_size_ - 1;
   if (i != last) {
     isolates_[i] = isolates_[last];
   }
   // Mark last as NULL.
   isolates_[last] = NULL;
   // Pop.
   isolates_size_--;
 }
@@ skipping 282 matching lines @@
     original_pc_(pc),
     original_fp_(fp),
     original_sp_(sp),
     lower_bound_(stack_lower) {
   ASSERT(sample_ != NULL);
 }
 
 
 int ProfilerSampleStackWalker::walk() {
   uword* pc = reinterpret_cast<uword*>(original_pc_);
+#if defined(WALK_STACK)
   uword* fp = reinterpret_cast<uword*>(original_fp_);
   uword* previous_fp = fp;
   if (original_sp_ < lower_bound_) {
     // The stack pointer gives us a better lower bound than
     // the isolates stack limit.
     lower_bound_ = original_sp_;
   }
   int i = 0;
   for (; i < Sample::kNumStackFrames; i++) {
     sample_->pcs[i] = reinterpret_cast<uintptr_t>(pc);
     if (!ValidFramePointer(fp)) {
       break;
     }
     pc = CallerPC(fp);
     previous_fp = fp;
     fp = CallerFP(fp);
     if ((fp <= previous_fp) || !ValidFramePointer(fp)) {
       // Frame pointers should only move to higher addresses.
       break;
     }
     // Move the lower bound up.
     lower_bound_ = reinterpret_cast<uintptr_t>(fp);
   }
   return i;
+#else
+  sample_->pcs[0] = reinterpret_cast<uintptr_t>(pc);
+  return 0;
+#endif
 }
 
 
 uword* ProfilerSampleStackWalker::CallerPC(uword* fp) {
   ASSERT(fp != NULL);
   return reinterpret_cast<uword*>(*(fp + 1));
 }
 
 
 uword* ProfilerSampleStackWalker::CallerFP(uword* fp) {
   ASSERT(fp != NULL);
   return reinterpret_cast<uword*>(*fp);
 }
 
 
 bool ProfilerSampleStackWalker::ValidFramePointer(uword* fp) {
   if (fp == NULL) {
     return false;
   }
   uintptr_t cursor = reinterpret_cast<uintptr_t>(fp);
   cursor += sizeof(fp);
   bool r = cursor >= lower_bound_ && cursor < stack_upper_;
   return r;
 }
 
 
 }  // namespace dart