Add Thread TaskKind

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 "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/atomic.h"
@@ skipping 100 matching lines @@
   CACHED_VM_OBJECTS_LIST(V)                                                    \
   CACHED_ADDRESSES_LIST(V)                                                     \
 
 // 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 BaseThread {
  public:
+  // The kind of task this thread is performing. Sampled by the profiler.
+  enum TaskKind {
+    kUnknownTask = 0x0,
+    kMutatorTask = 0x1,
+    kCompilerTask = 0x2,
+    kSweeperTask = 0x4,
+    kMarkerTask = 0x8,
+  };
   ~Thread();
 
   // The currently executing thread, or NULL if not yet initialized.
   static Thread* Current() {
     BaseThread* thread = OSThread::GetCurrentTLS();
     if (thread == NULL || thread->is_os_thread()) {
       return NULL;
     }
     return reinterpret_cast<Thread*>(thread);
   }
 
   // Makes the current thread enter 'isolate'.
   static bool EnterIsolate(Isolate* isolate);
   // Makes the current thread exit its isolate.
   static void ExitIsolate();
 
   // A VM thread other than the main mutator thread can enter an isolate as a
   // "helper" to gain limited concurrent access to the isolate. One example is
   // SweeperTask (which uses the class table, which is copy-on-write).
   // TODO(koda): Properly synchronize heap access to expand allowed operations.
   static bool EnterIsolateAsHelper(Isolate* isolate,
+                                   TaskKind kind,
                                    bool bypass_safepoint = false);
   static void ExitIsolateAsHelper(bool bypass_safepoint = false);
 
   // Empties the store buffer block into the isolate.
   void PrepareForGC();
 
   void SetStackLimit(uword value);
   void SetStackLimitFromStackBase(uword stack_base);
   void ClearStackLimit();
 
@@ skipping 22 matching lines @@
     return reinterpret_cast<uword>(&stack_overflow_flags_);
   }
   static intptr_t stack_overflow_flags_offset() {
     return OFFSET_OF(Thread, stack_overflow_flags_);
   }
 
   int32_t IncrementAndGetStackOverflowCount() {
     return ++stack_overflow_count_;
   }
 
+  TaskKind task_kind() const {
+    return task_kind_;
+  }
+
   // Retrieves and clears the stack overflow flags.  These are set by
   // the generated code before the slow path runtime routine for a
   // stack overflow is called.
   uword GetAndClearStackOverflowFlags();
 
   // Interrupt bits.
   enum {
     kVMInterrupt = 0x1,  // Internal VM checks: safepoints, store buffers, etc.
     kMessageInterrupt = 0x2,  // An interrupt to process an out of band message.
 
@@ skipping 394 matching lines @@
   template<class T> T* AllocateReusableHandle();
 
   // Accessed from generated code:
   uword stack_limit_;
   uword stack_overflow_flags_;
   Isolate* isolate_;
   Heap* heap_;
   uword top_exit_frame_info_;
   StoreBufferBlock* store_buffer_block_;
   uword vm_tag_;
+  TaskKind task_kind_;
   // State that is cached in the TLS for fast access in generated code.
 #define DECLARE_MEMBERS(type_name, member_name, expr, default_init_value)      \
   type_name member_name;
 CACHED_CONSTANTS_LIST(DECLARE_MEMBERS)
 #undef DECLARE_MEMBERS
 
 #define DECLARE_MEMBERS(name)      \
   uword name##_entry_point_;
 RUNTIME_ENTRY_LIST(DECLARE_MEMBERS)
 #undef DECLARE_MEMBERS
@@ skipping 105 matching lines @@
 // Disable thread interrupts.
 class DisableThreadInterruptsScope : public StackResource {
  public:
   explicit DisableThreadInterruptsScope(Thread* thread);
   ~DisableThreadInterruptsScope();
 };
 
 }  // namespace dart
 
 #endif  // VM_THREAD_H_