Switch profiler from isolates to threads

runtime/vm/thread.h

 // Copyright (c) 2015, 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.
 
 #ifndef VM_THREAD_H_
 #define VM_THREAD_H_
 
 #include "vm/globals.h"
 #include "vm/handles.h"
 #include "vm/os_thread.h"
@@ skipping 74 matching lines @@
   V(uword, native_call_wrapper_entry_point_,                                   \
     NativeEntry::NativeCallWrapperEntry(), 0)                                  \
   V(RawString**, predefined_symbols_address_,                                  \
     Symbols::PredefinedAddress(), NULL)                                        \
 
 #define CACHED_CONSTANTS_LIST(V)                                               \
   CACHED_VM_OBJECTS_LIST(V)                                                    \
   CACHED_ADDRESSES_LIST(V)                                                     \
 
 struct InterruptedThreadState {
-  ThreadId tid;
   uintptr_t pc;
   uintptr_t csp;
   uintptr_t dsp;
   uintptr_t fp;
   uintptr_t lr;
 };
 
 // When a thread is interrupted the thread specific interrupt callback will be
 // invoked. Each callback is given an InterruptedThreadState and the user data
 // pointer. When inside a thread interrupt callback doing any of the following
 // is forbidden:
 //   * Accessing TLS -- Because on Windows the callback will be running in a
 //                      different thread.
 //   * Allocating memory -- Because this takes locks which may already be held,
 //                          resulting in a dead lock.
 //   * Taking a lock -- See above.
-typedef void (*ThreadInterruptCallback)(const InterruptedThreadState& state,
-                                        void* data);
+typedef void (*ThreadInterruptCallback)(Thread* thread,
+                                        const InterruptedThreadState& state);
 
 // A VM thread; may be executing Dart code or performing helper tasks like
 // garbage collection or compilation. The Thread structure associated with
 // a thread is allocated by EnsureInit before entering an isolate, and destroyed
 // automatically when the underlying OS thread exits. NOTE: On Windows, CleanUp
 // must currently be called manually (issue 23474).
 class Thread {
  public:
   // The currently executing thread, or NULL if not yet initialized.
   static Thread* Current() {
@@ skipping 32 matching lines @@
   // The topmost zone used for allocation in this thread.
   Zone* zone() const { return state_.zone; }
 
   // The isolate that this thread is operating on, or NULL if none.
   Isolate* isolate() const { return isolate_; }
   static intptr_t isolate_offset() {
     return OFFSET_OF(Thread, isolate_);
   }
   bool IsMutatorThread() const;
 
+  // Is |this| executing Dart code?
+  bool IsExecutingDartCode() const;
+
+  // Has |this| exited Dart code?
+  bool HasExitedDartCode() const;
+
   // The (topmost) CHA for the compilation in this thread.
   CHA* cha() const;
   void set_cha(CHA* value);
 
   int32_t no_callback_scope_depth() const {
     return no_callback_scope_depth_;
   }
 
   void IncrementNoCallbackScopeDepth() {
     ASSERT(no_callback_scope_depth_ < INT_MAX);
@@ skipping 194 matching lines @@
   ThreadId id() const {
     ASSERT(id_ != OSThread::kInvalidThreadId);
     return id_;
   }
 
   ThreadId join_id() const {
     ASSERT(join_id_ != OSThread::kInvalidThreadJoinId);
     return join_id_;
   }
 
-  void SetThreadInterrupter(ThreadInterruptCallback callback, void* data);
+  // Used to temporarily disable or enable thread interrupts.
+  void DisableThreadInterrupts();
+  void EnableThreadInterrupts();
+  bool ThreadInterruptsEnabled();
 
-  bool IsThreadInterrupterEnabled(ThreadInterruptCallback* callback,
-                                  void** data) const;
+  void SetThreadInterruptCallback(ThreadInterruptCallback callback);
+
+  // Returns true if *callback != null.
+  bool GetThreadInterruptCallback(ThreadInterruptCallback* callback) const;
 
 #if defined(DEBUG)
 #define REUSABLE_HANDLE_SCOPE_ACCESSORS(object)                                \
   void set_reusable_##object##_handle_scope_active(bool value) {               \
     reusable_##object##_handle_scope_active_ = value;                          \
   }                                                                            \
   bool reusable_##object##_handle_scope_active() const {                       \
     return reusable_##object##_handle_scope_active_;                           \
   }
   REUSABLE_HANDLE_LIST(REUSABLE_HANDLE_SCOPE_ACCESSORS)
@@ skipping 24 matching lines @@
   static bool IsThreadInList(ThreadId join_id);
 
  private:
   template<class T> T* AllocateReusableHandle();
 
   static ThreadLocalKey thread_key_;
 
   const ThreadId id_;
   const ThreadId join_id_;
   ThreadInterruptCallback thread_interrupt_callback_;
-  void* thread_interrupt_data_;
+  uintptr_t thread_interrupt_disabled_;
   Isolate* isolate_;
   Heap* heap_;
   State state_;
   Mutex timeline_block_lock_;
   TimelineEventBlock* timeline_block_;
   StoreBufferBlock* store_buffer_block_;
   class Log* log_;
 #define DECLARE_MEMBERS(type_name, member_name, expr, default_init_value)      \
   type_name member_name;
 CACHED_CONSTANTS_LIST(DECLARE_MEMBERS)
@@ skipping 99 matching lines @@
 };
 
 #if defined(TARGET_OS_WINDOWS)
 // Clears the state of the current thread and frees the allocation.
 void WindowsThreadCleanUp();
 #endif
 
 }  // namespace dart
 
 #endif  // VM_THREAD_H_