Revert "Switch profiler from isolates to threads"

runtime/vm/isolate.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 "vm/isolate.h"
 
 #include "include/dart_api.h"
 #include "include/dart_native_api.h"
 #include "platform/assert.h"
 #include "platform/json.h"
@@ skipping 766 matching lines @@
       defer_finalization_count_(0),
       deopt_context_(NULL),
       compiler_stats_(NULL),
       is_service_isolate_(false),
       stacktrace_(NULL),
       stack_frame_index_(-1),
       last_allocationprofile_accumulator_reset_timestamp_(0),
       last_allocationprofile_gc_timestamp_(0),
       object_id_ring_(NULL),
       trace_buffer_(NULL),
+      profiler_data_(NULL),
       tag_table_(GrowableObjectArray::null()),
       deoptimized_code_array_(GrowableObjectArray::null()),
       background_compiler_(NULL),
       pending_service_extension_calls_(GrowableObjectArray::null()),
       registered_service_extension_handlers_(GrowableObjectArray::null()),
       metrics_list_head_(NULL),
       compilation_allowed_(true),
       all_classes_finalized_(false),
       next_(NULL),
       pause_loop_monitor_(NULL),
@@ skipping 911 matching lines @@
     MonitorLocker ml(old_space->tasks_lock());
     ASSERT(old_space->tasks() == 0);
   }
 #endif
 
   // TODO(5411455): For now just make sure there are no current isolates
   // as we are shutting down the isolate.
   Thread::ExitIsolate();
   // All threads should have exited by now.
   thread_registry()->CheckNotScheduled(this);
+  Profiler::ShutdownProfilingForIsolate(this);
 }
 
 
 Dart_IsolateCreateCallback Isolate::create_callback_ = NULL;
 Dart_IsolateInterruptCallback Isolate::interrupt_callback_ = NULL;
 Dart_IsolateUnhandledExceptionCallback
     Isolate::unhandled_exception_callback_ = NULL;
 Dart_IsolateShutdownCallback Isolate::shutdown_callback_ = NULL;
 Dart_FileOpenCallback Isolate::file_open_callback_ = NULL;
 Dart_FileReadCallback Isolate::file_read_callback_ = NULL;
@@ skipping 184 matching lines @@
     debugger()->PrintBreakpointsToJSONArray(&breakpoints);
   }
 
   {
     JSONObject jssettings(&jsobj, "_debuggerSettings");
     debugger()->PrintSettingsToJSONObject(&jssettings);
   }
 }
 
 
+intptr_t Isolate::ProfileInterrupt() {
+  // Other threads might be modifying these fields. Save them in locals so that
+  // we can at least trust the NULL check.
+  IsolateProfilerData* prof_data = profiler_data();
+  if (prof_data == NULL) {
+    // Profiler not setup for isolate.
+    return 0;
+  }
+  if (prof_data->blocked()) {
+    // Profiler blocked for this isolate.
+    return 0;
+  }
+  Debugger* debug = debugger();
+  if ((debug != NULL) && debug->IsPaused()) {
+    // Paused at breakpoint. Don't tick.
+    return 0;
+  }
+  MessageHandler* msg_handler = message_handler();
+  if ((msg_handler != NULL) &&
+      (msg_handler->paused_on_start() ||
+       msg_handler->paused_on_exit())) {
+    // Paused at start / exit . Don't tick.
+    return 0;
+  }
+  // Make sure that the isolate's mutator thread does not change behind our
+  // backs. Otherwise we find the entry in the registry and end up reading
+  // the field again. Only by that time it has been reset to NULL because the
+  // thread was in process of exiting the isolate.
+  Thread* mutator = mutator_thread_;
+  if (mutator == NULL) {
+    // No active mutator.
+    ProfileIdle();
+    return 1;
+  }
+
+  // TODO(johnmccutchan): Sample all threads, not just the mutator thread.
+  // TODO(johnmccutchan): Keep a global list of threads and use that
+  // instead of Isolate.
+  ThreadRegistry::EntryIterator it(thread_registry());
+  while (it.HasNext()) {
+    const ThreadRegistry::Entry& entry = it.Next();
+    if (entry.thread == mutator) {
+      ThreadInterrupter::InterruptThread(mutator);
+      break;
+    }
+  }
+  return 1;
+}
+
+
+void Isolate::ProfileIdle() {
+  // Currently we are only sampling the mutator thread.
+  vm_tag_counters_.Increment(VMTag::kIdleTagId);
+}
+
+
 void Isolate::set_tag_table(const GrowableObjectArray& value) {
   tag_table_ = value.raw();
 }
 
 
 void Isolate::set_current_tag(const UserTag& tag) {
   uword user_tag = tag.tag();
   ASSERT(user_tag < kUwordMax);
   set_user_tag(user_tag);
   current_tag_ = tag.raw();
@@ skipping 605 matching lines @@
 }
 
 
 RawInstance* IsolateSpawnState::BuildMessage(Thread* thread) {
   return DeserializeObject(thread,
                            serialized_message_, serialized_message_len_);
 }
 
 
 }  // namespace dart