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

runtime/vm/os_thread_win.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 "platform/globals.h"  // NOLINT
 #if defined(TARGET_OS_WINDOWS)
 
 #include "vm/growable_array.h"
 #include "vm/os_thread.h"
 
 #include <process.h>  // NOLINT
 
 #include "platform/assert.h"
 
 namespace dart {
 
 // This flag is flipped by platform_win.cc when the process is exiting.
 // TODO(zra): Remove once VM shuts down cleanly.
 bool private_flag_windows_run_tls_destructors = true;
 
 class ThreadStartData {
  public:
-  ThreadStartData(OSThread::ThreadStartFunction function, uword parameter)
-      : function_(function), parameter_(parameter) {}
+  ThreadStartData(const char* name,
+                  OSThread::ThreadStartFunction function,
+                  uword parameter)
+      : name_(name), function_(function), parameter_(parameter) {}
 
+  const char* name() const { return name_; }
   OSThread::ThreadStartFunction function() const { return function_; }
   uword parameter() const { return parameter_; }
 
  private:
+  const char* name_;
   OSThread::ThreadStartFunction function_;
   uword parameter_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadStartData);
 };
 
 
 // Dispatch to the thread start function provided by the caller. This trampoline
 // is used to ensure that the thread is properly destroyed if the thread just
 // exits.
 static unsigned int __stdcall ThreadEntry(void* data_ptr) {
   ThreadStartData* data = reinterpret_cast<ThreadStartData*>(data_ptr);
 
+  const char* name = data->name();
   OSThread::ThreadStartFunction function = data->function();
   uword parameter = data->parameter();
   delete data;
 
   MonitorData::GetMonitorWaitDataForThread();
 
+  // Create new OSThread object and set as TLS for new thread.
+  OSThread* thread = new OSThread();
+  OSThread::SetCurrent(thread);
+  thread->set_name(name);
+
   // Call the supplied thread start function handing it its parameters.
   function(parameter);
 
   // Clean up the monitor wait data for this thread.
   MonitorWaitData::ThreadExit();
 
   return 0;
 }
 
 
-int OSThread::Start(ThreadStartFunction function, uword parameter) {
-  ThreadStartData* start_data = new ThreadStartData(function, parameter);
+int OSThread::Start(const char* name,
+                    ThreadStartFunction function,
+                    uword parameter) {
+  ThreadStartData* start_data = new ThreadStartData(name, function, parameter);
   uint32_t tid;
   uintptr_t thread = _beginthreadex(NULL, OSThread::GetMaxStackSize(),
                                     ThreadEntry, start_data, 0, &tid);
   if (thread == -1L || thread == 0) {
 #ifdef DEBUG
     fprintf(stderr, "_beginthreadex error: %d (%s)\n", errno, strerror(errno));
 #endif
     return errno;
   }
 
@@ skipping 37 matching lines @@
   return ::GetCurrentThreadId();
 }
 
 
 ThreadId OSThread::GetCurrentThreadTraceId() {
   return ::GetCurrentThreadId();
 }
 
 
 ThreadJoinId OSThread::GetCurrentThreadJoinId() {
   return ::GetCurrentThreadId();

[zra, 2015/11/16 20:12:28]

Now that the join_id is stored on the OSThread in TLS, we can make a more
reliable thread join on Windows by changing ThreadJoinId to be a HANDLE for the
thread. If you'd like, I can take a look at doing that and you can add a TODO
for me here or where the ThreadJoinId type is defined.

[siva, 2015/11/17 20:52:25]

I have added a TODO(zra) here.

 }
 
 
 void OSThread::Join(ThreadJoinId id) {
   HANDLE handle = OpenThread(SYNCHRONIZE, false, id);
 
   // TODO(zra): OSThread::Start() closes the handle to the thread. Thus, by the
   // time we try to join the thread, its resources may have already been
   // reclaimed, and joining will fail. This can be avoided in a couple of ways.

[zra, 2015/11/16 20:12:28]

Stuff after "and joining will fail." is stale after this CL.

[siva, 2015/11/17 20:52:25]

Will let you change this comment after you make the change of using the handle
as a join id, as it is possible that the handle maybe closed before the join id
is extracted.

   // First, GetCurrentThreadJoinId could call OpenThread and return a handle.
   // This is bad, because each of those handles would have to be closed.
   // Second OSThread could be refactored to no longer be AllStatic. Then the
   // handle could be cached in the object by the Start method.
   if (handle == NULL) {
     return;
   }
 
   DWORD res = WaitForSingleObject(handle, INFINITE);
   CloseHandle(handle);
@@ skipping 546 matching lines @@
 #pragma data_seg(".CRT$XLB")
 PIMAGE_TLS_CALLBACK p_thread_callback_dart = OnDartThreadExit;
 
 // Reset the default section.
 #pragma data_seg()
 
 #endif  // _WIN64
 }  // extern "C"
 
 #endif  // defined(TARGET_OS_WINDOWS)