Add Thread TaskKind

runtime/vm/thread.cc

 // 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.
 
 #include "vm/thread.h"
 
 #include "vm/dart_api_state.h"
 #include "vm/growable_array.h"
 #include "vm/isolate.h"
 #include "vm/lockers.h"
@@ skipping 45 matching lines @@
 
 Thread::Thread(Isolate* isolate)
     : BaseThread(false),
       stack_limit_(0),
       stack_overflow_flags_(0),
       isolate_(NULL),
       heap_(NULL),
       top_exit_frame_info_(0),
       store_buffer_block_(NULL),
       vm_tag_(0),
+      task_kind_(kUnknownTask),
       os_thread_(NULL),
       thread_lock_(new Monitor()),
       zone_(NULL),
       api_reusable_scope_(NULL),
       api_top_scope_(NULL),
       top_resource_(NULL),
       long_jump_base_(NULL),
       no_callback_scope_depth_(0),
 #if defined(DEBUG)
       top_handle_scope_(NULL),
@@ skipping 141 matching lines @@
 void Thread::clear_sticky_error() {
   sticky_error_ = Error::null();
 }
 
 
 bool Thread::EnterIsolate(Isolate* isolate) {
   const bool kIsMutatorThread = true;
   Thread* thread = isolate->ScheduleThread(kIsMutatorThread);
   if (thread != NULL) {
     ASSERT(thread->store_buffer_block_ == NULL);
+    thread->task_kind_ = kMutatorTask;
     thread->StoreBufferAcquire();
     return true;
   }
   return false;
 }
 
 
 void Thread::ExitIsolate() {
   Thread* thread = Thread::Current();
   ASSERT(thread != NULL && thread->IsMutatorThread());
   DEBUG_ASSERT(!thread->IsAnyReusableHandleScopeActive());
-
+  thread->task_kind_ = kUnknownTask;
   Isolate* isolate = thread->isolate();
   ASSERT(isolate != NULL);
   ASSERT(thread->execution_state() == Thread::kThreadInVM);
   // Clear since GC will not visit the thread once it is unscheduled.
   thread->ClearReusableHandles();
   thread->StoreBufferRelease();
   if (isolate->is_runnable()) {
     thread->set_vm_tag(VMTag::kIdleTagId);
   } else {
     thread->set_vm_tag(VMTag::kLoadWaitTagId);
   }
   const bool kIsMutatorThread = true;
   isolate->UnscheduleThread(thread, kIsMutatorThread);
 }
 
 
-bool Thread::EnterIsolateAsHelper(Isolate* isolate, bool bypass_safepoint) {
+bool Thread::EnterIsolateAsHelper(Isolate* isolate,
+                                  TaskKind kind,
+                                  bool bypass_safepoint) {
   const bool kIsNotMutatorThread = false;
   Thread* thread = isolate->ScheduleThread(kIsNotMutatorThread,
                                            bypass_safepoint);
   if (thread != NULL) {
     ASSERT(thread->store_buffer_block_ == NULL);
     // TODO(koda): Use StoreBufferAcquire once we properly flush
     // before Scavenge.
     thread->store_buffer_block_ =
         thread->isolate()->store_buffer()->PopEmptyBlock();
     // This thread should not be the main mutator.
+    thread->task_kind_ = kind;

[siva, 2016/03/18 22:48:41]

ASSERT(kind != kMutatorTask);

[Cutch, 2016/03/21 16:35:04]

Done.

     ASSERT(!thread->IsMutatorThread());
     return true;
   }
   return false;
 }
 
 
 void Thread::ExitIsolateAsHelper(bool bypass_safepoint) {
   Thread* thread = Thread::Current();
   ASSERT(thread != NULL);
   ASSERT(!thread->IsMutatorThread());
   ASSERT(thread->execution_state() == Thread::kThreadInVM);
+  thread->task_kind_ = kUnknownTask;
   // Clear since GC will not visit the thread once it is unscheduled.
   thread->ClearReusableHandles();
   thread->StoreBufferRelease();
   Isolate* isolate = thread->isolate();
   ASSERT(isolate != NULL);
   const bool kIsNotMutatorThread = false;
   isolate->UnscheduleThread(thread, kIsNotMutatorThread, bypass_safepoint);
 }
 
 
@@ skipping 416 matching lines @@
 
 DisableThreadInterruptsScope::~DisableThreadInterruptsScope() {
   if (thread() != NULL) {
     OSThread* os_thread = thread()->os_thread();
     ASSERT(os_thread != NULL);
     os_thread->EnableThreadInterrupts();
   }
 }
 
 }  // namespace dart