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

runtime/vm/timeline.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 <cstdlib>
 
 #include "vm/atomic.h"
 #include "vm/isolate.h"
 #include "vm/json_stream.h"
 #include "vm/lockers.h"
@@ skipping 108 matching lines @@
 }
 
 
 void Timeline::ReclaimCachedBlocksFromThreads() {
   TimelineEventRecorder* recorder = Timeline::recorder();
   if (recorder == NULL) {
     return;
   }
 
   // Iterate over threads.
-  ThreadIterator it;
+  OSThreadIterator it;
   while (it.HasNext()) {
-    Thread* thread = it.Next();
+    OSThread* thread = it.Next();
     MutexLocker ml(thread->timeline_block_lock());
     // Grab block and clear it.
     TimelineEventBlock* block = thread->timeline_block();
     thread->set_timeline_block(NULL);
     // TODO(johnmccutchan): Consider dropping the timeline_block_lock here
     // if we can do it everywhere. This would simplify the lock ordering
     // requirements.
     recorder->FinishBlock(block);
   }
 }
@@ skipping 201 matching lines @@
   }
 }
 
 
 void TimelineEvent::Init(EventType event_type,
                          const char* label) {
   ASSERT(label != NULL);
   set_event_type(event_type);
   timestamp0_ = 0;
   timestamp1_ = 0;
-  thread_ = OSThread::GetCurrentThreadTraceId();
+  OSThread* os_thread = OSThread::Current();
+  ASSERT(os_thread != NULL);
+  thread_ = os_thread->trace_id();
   Isolate* isolate = Isolate::Current();
   if (isolate != NULL) {
     isolate_id_ = isolate->main_port();
   } else {
     isolate_id_ = ILLEGAL_PORT;
   }
   label_ = label;
   FreeArguments();
 }
 
@@ skipping 270 matching lines @@
     : isolate_id_(isolate_id) {
 }
 
 
 TimelineEventRecorder::TimelineEventRecorder()
     : async_id_(0) {
 }
 
 
 void TimelineEventRecorder::PrintJSONMeta(JSONArray* events) const {
-  ThreadIterator it;
+  OSThreadIterator it;
   while (it.HasNext()) {
-    Thread* thread = it.Next();
+    OSThread* thread = it.Next();
     const char* thread_name = thread->name();
     if (thread_name == NULL) {
       // Only emit a thread name if one was set.
       continue;
     }
     JSONObject obj(events);
     int64_t pid = OS::ProcessId();
     int64_t tid = OSThread::ThreadIdToIntPtr(thread->trace_id());
     obj.AddProperty("name", "thread_name");
     obj.AddProperty("ph", "M");
     obj.AddProperty64("pid", pid);
     obj.AddProperty64("tid", tid);
     {
       JSONObject args(&obj, "args");
       args.AddPropertyF("name", "%s (%" Pd64 ")", thread_name, tid);
     }
   }
 }
 
 
 TimelineEvent* TimelineEventRecorder::ThreadBlockStartEvent() {
   // Grab the current thread.
-  Thread* thread = Thread::Current();
+  OSThread* thread = OSThread::Current();
   ASSERT(thread != NULL);
   Mutex* thread_block_lock = thread->timeline_block_lock();
   ASSERT(thread_block_lock != NULL);
   // We are accessing the thread's timeline block- so take the lock here.
   // This lock will be held until the call to |CompleteEvent| is made.
   thread_block_lock->Lock();
 
   TimelineEventBlock* thread_block = thread->timeline_block();
 
   if ((thread_block != NULL) && thread_block->IsFull()) {
@@ skipping 20 matching lines @@
   thread_block_lock->Unlock();
   return NULL;
 }
 
 
 void TimelineEventRecorder::ThreadBlockCompleteEvent(TimelineEvent* event) {
   if (event == NULL) {
     return;
   }
   // Grab the current thread.
-  Thread* thread = Thread::Current();
+  OSThread* thread = OSThread::Current();
   ASSERT(thread != NULL);
   // Unlock the thread's block lock.
   Mutex* thread_block_lock = thread->timeline_block_lock();
   ASSERT(thread_block_lock != NULL);
   thread_block_lock->Unlock();
 }
 
 
 void TimelineEventRecorder::WriteTo(const char* directory) {
   Dart_FileOpenCallback file_open = Isolate::file_open_callback();
@@ skipping 173 matching lines @@
     if (block->LowerTimeBound() < earliest_time) {
       earliest_time = block->LowerTimeBound();
       earliest_index = block_idx;
     }
   }
   return earliest_index;
 }
 
 
 TimelineEvent* TimelineEventRingRecorder::StartEvent() {
-  // Grab the current thread.
-  Thread* thread = Thread::Current();
-  ASSERT(thread != NULL);
   return ThreadBlockStartEvent();
 }
 
 
 void TimelineEventRingRecorder::CompleteEvent(TimelineEvent* event) {
   if (event == NULL) {
     return;
   }
   ThreadBlockCompleteEvent(event);
 }
@@ skipping 62 matching lines @@
   PrintJSONEvents(&events, filter);
 }
 
 
 TimelineEventBlock* TimelineEventEndlessRecorder::GetHeadBlockLocked() {
   return head_;
 }
 
 
 TimelineEvent* TimelineEventEndlessRecorder::StartEvent() {
-  // Grab the current thread.
-  Thread* thread = Thread::Current();
-  ASSERT(thread != NULL);
   return ThreadBlockStartEvent();
 }
 
 
 void TimelineEventEndlessRecorder::CompleteEvent(TimelineEvent* event) {
   if (event == NULL) {
     return;
   }
   ThreadBlockCompleteEvent(event);
 }
@@ skipping 36 matching lines @@
 
 void TimelineEventEndlessRecorder::Clear() {
   TimelineEventBlock* current = head_;
   while (current != NULL) {
     TimelineEventBlock* next = current->next();
     delete current;
     current = next;
   }
   head_ = NULL;
   block_index_ = 0;
-  Thread* thread = Thread::Current();
+  OSThread* thread = OSThread::Current();
   thread->set_timeline_block(NULL);
 }
 
 
 TimelineEventBlock::TimelineEventBlock(intptr_t block_index)
     : next_(NULL),
       length_(0),
       block_index_(block_index),
       thread_id_(OSThread::kInvalidThreadId),
       in_use_(false) {
 }
 
 
 TimelineEventBlock::~TimelineEventBlock() {
   Reset();
 }
 
 
 TimelineEvent* TimelineEventBlock::StartEvent() {
   ASSERT(!IsFull());
   if (FLAG_trace_timeline) {
-    OS::Print("StartEvent in block %p for thread %" Px "\n",
-              this, OSThread::CurrentCurrentThreadIdAsIntPtr());
+    OSThread* os_thread = OSThread::Current();
+    ASSERT(os_thread != NULL);
+    intptr_t tid = OSThread::ThreadIdToIntPtr(os_thread->id());
+    OS::Print("StartEvent in block %p for thread %" Px "\n", this, tid);
   }
   return &events_[length_++];
 }
 
 
 int64_t TimelineEventBlock::LowerTimeBound() const {
   if (length_ == 0) {
     return kMaxInt64;
   }
   ASSERT(length_ > 0);
@@ skipping 30 matching lines @@
     // Clear any extra data.
     events_[i].Reset();
   }
   length_ = 0;
   thread_id_ = OSThread::kInvalidThreadId;
   in_use_ = false;
 }
 
 
 void TimelineEventBlock::Open() {
-  thread_id_ = OSThread::GetCurrentThreadTraceId();
+  OSThread* os_thread = OSThread::Current();
+  ASSERT(os_thread != NULL);
+  thread_id_ = os_thread->trace_id();
   in_use_ = true;
 }
 
 
 void TimelineEventBlock::Finish() {
   if (FLAG_trace_timeline) {
     OS::Print("Finish block %p\n", this);
   }
   in_use_ = false;
 }
@@ skipping 36 matching lines @@
 
 
 TimelineEventBlock* TimelineEventBlockIterator::Next() {
   ASSERT(current_ != NULL);
   TimelineEventBlock* r = current_;
   current_ = current_->next();
   return r;
 }
 
 }  // namespace dart