- Add an OSThread structure which is the generic TLS structure for all C++

runtime/vm/thread_pool.cc

 // Copyright (c) 2012, 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_pool.h"
 
 #include "vm/flags.h"
 #include "vm/lockers.h"
 
 namespace dart {
@@ skipping 83 matching lines @@
     count_running_ = 0;
     ASSERT(count_started_ == count_stopped_);
   }
   // Release ThreadPool::mutex_ before calling Worker functions.
 
   {
     MonitorLocker eml(&exit_monitor_);
 
     // First tell all the workers to shut down.
     Worker* current = saved;
-    ThreadId id = OSThread::GetCurrentThreadId();
+    OSThread* os_thread = OSThread::Current();
+    ASSERT(os_thread != NULL);
+    ThreadId id = os_thread->id();
     while (current != NULL) {
       Worker* next = current->all_next_;
       ThreadId currentId = current->id();
       if (currentId != id) {
         AddWorkerToShutdownList(current);
       }
       current->Shutdown();
       current = next;
     }
     saved = NULL;
@@ skipping 123 matching lines @@
   // Remove from idle list.
   if (!RemoveWorkerFromIdleList(worker)) {
     return false;
   }
   // Remove from all list.
   bool found = RemoveWorkerFromAllList(worker);
   ASSERT(found);
 
   // The thread for worker will exit. Add its ThreadId to the join_list_
   // so that we can join on it at the next opportunity.
-  JoinList::AddLocked(OSThread::GetCurrentThreadJoinId(), &join_list_);
+  OSThread* os_thread = OSThread::Current();
+  ASSERT(os_thread != NULL);
+  JoinList::AddLocked(os_thread->join_id(), &join_list_);
   count_stopped_++;
   count_idle_--;
   return true;
 }
 
 
 // Only call while holding the exit_monitor_
 void ThreadPool::AddWorkerToShutdownList(Worker* worker) {
   worker->shutdown_next_ = shutting_down_workers_;
   shutting_down_workers_ = worker;
@@ skipping 67 matching lines @@
 
 
 void ThreadPool::Worker::StartThread() {
 #if defined(DEBUG)
   // Must call SetTask before StartThread.
   { // NOLINT
     MonitorLocker ml(&monitor_);
     ASSERT(task_ != NULL);
   }
 #endif
-  int result = OSThread::Start(&Worker::Main, reinterpret_cast<uword>(this));
+  int result = OSThread::Start("Dart ThreadPool Worker",
+                               &Worker::Main,
+                               reinterpret_cast<uword>(this));
   if (result != 0) {
     FATAL1("Could not start worker thread: result = %d.", result);
   }
 }
 
 
 void ThreadPool::Worker::SetTask(Task* task) {
   MonitorLocker ml(&monitor_);
   ASSERT(task_ == NULL);
   task_ = task;
@@ skipping 63 matching lines @@
 
 void ThreadPool::Worker::Shutdown() {
   MonitorLocker ml(&monitor_);
   done_ = true;
   ml.Notify();
 }
 
 
 // static
 void ThreadPool::Worker::Main(uword args) {
-  Thread::EnsureInit();
-  Thread* thread = Thread::Current();
-  thread->set_name("Dart ThreadPool Worker");
   Worker* worker = reinterpret_cast<Worker*>(args);
-  ThreadId id = OSThread::GetCurrentThreadId();
-  ThreadJoinId join_id = OSThread::GetCurrentThreadJoinId();
+  OSThread* os_thread = OSThread::Current();
+  ASSERT(os_thread != NULL);
+  ThreadId id = os_thread->id();
+  ThreadJoinId join_id = os_thread->join_id();
   ThreadPool* pool;
 
   {
     MonitorLocker ml(&worker->monitor_);
     ASSERT(worker->task_);
     worker->id_ = id;
     pool = worker->pool_;
   }
 
   bool released = worker->Loop();
@@ skipping 33 matching lines @@
     // is not due to a ThreadPool Shutdown. Thus, we simply delete the worker.
     // The worker's id is added to the thread pool's join list by
     // ReleaseIdleWorker, so in the case that the thread pool begins shutting
     // down immediately after returning from worker->Loop() above, we still
     // wait for the thread to exit by joining on it in Shutdown().
     delete worker;
   }
 }
 
 }  // namespace dart