runtime/vm/os_thread_win.cc - sdk.git - Git at Google

 // 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(DART_HOST_OS_WINDOWS)

 #include "vm/growable_array.h"
 #include "vm/lockers.h"
 #include "vm/os_thread.h"

 #include <process.h>  // NOLINT

 #include "platform/address_sanitizer.h"
 #include "platform/assert.h"
 #include "platform/safe_stack.h"

 #include "vm/flags.h"

 namespace dart {

 DEFINE_FLAG(int,
             worker_thread_priority,
             kMinInt,
             "The thread priority the VM should use for new worker threads.");

 // 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(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) {
   if (FLAG_worker_thread_priority != kMinInt) {
     if (SetThreadPriority(GetCurrentThread(), FLAG_worker_thread_priority) ==
         0) {
       FATAL2("Setting thread priority to %d failed: GetLastError() = %d\n",
              FLAG_worker_thread_priority, GetLastError());
     }
   }

   ThreadStartData* data = reinterpret_cast<ThreadStartData*>(data_ptr);

   const char* name = data->name();
   OSThread::ThreadStartFunction function = data->function();
   uword parameter = data->parameter();
   delete data;

   // Create new OSThread object and set as TLS for new thread.
   OSThread* thread = OSThread::CreateOSThread();
   if (thread != NULL) {
     OSThread::SetCurrent(thread);
     thread->set_name(name);

     // Call the supplied thread start function handing it its parameters.
     function(parameter);
   }

   return 0;
 }

 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;
   }

   // Close the handle, so we don't leak the thread object.
   CloseHandle(reinterpret_cast<HANDLE>(thread));

   return 0;
 }

 const ThreadId OSThread::kInvalidThreadId = 0;
 const ThreadJoinId OSThread::kInvalidThreadJoinId = NULL;

 ThreadLocalKey OSThread::CreateThreadLocal(ThreadDestructor destructor) {
   ThreadLocalKey key = TlsAlloc();
   if (key == kUnsetThreadLocalKey) {
     FATAL1("TlsAlloc failed %d", GetLastError());
   }
   ThreadLocalData::AddThreadLocal(key, destructor);
   return key;
 }

 void OSThread::DeleteThreadLocal(ThreadLocalKey key) {
   ASSERT(key != kUnsetThreadLocalKey);
   BOOL result = TlsFree(key);
   if (!result) {
     FATAL1("TlsFree failed %d", GetLastError());
   }
   ThreadLocalData::RemoveThreadLocal(key);
 }

 intptr_t OSThread::GetMaxStackSize() {
   const int kStackSize = (128 * kWordSize * KB);
   return kStackSize;
 }

 ThreadId OSThread::GetCurrentThreadId() {
   return ::GetCurrentThreadId();
 }

 #ifdef SUPPORT_TIMELINE
 ThreadId OSThread::GetCurrentThreadTraceId() {
   return ::GetCurrentThreadId();
 }
 #endif  // PRODUCT

 ThreadJoinId OSThread::GetCurrentThreadJoinId(OSThread* thread) {
   ASSERT(thread != NULL);
   // Make sure we're filling in the join id for the current thread.
   ThreadId id = GetCurrentThreadId();
   ASSERT(thread->id() == id);
   // Make sure the join_id_ hasn't been set, yet.
   DEBUG_ASSERT(thread->join_id_ == kInvalidThreadJoinId);
   HANDLE handle = OpenThread(SYNCHRONIZE, false, id);
   ASSERT(handle != NULL);
 #if defined(DEBUG)
   thread->join_id_ = handle;
 #endif
   return handle;
 }

 void OSThread::Join(ThreadJoinId id) {
   HANDLE handle = static_cast<HANDLE>(id);
   ASSERT(handle != NULL);
   DWORD res = WaitForSingleObject(handle, INFINITE);
   CloseHandle(handle);
   ASSERT(res == WAIT_OBJECT_0);
 }

 intptr_t OSThread::ThreadIdToIntPtr(ThreadId id) {
   ASSERT(sizeof(id) <= sizeof(intptr_t));
   return static_cast<intptr_t>(id);
 }

 ThreadId OSThread::ThreadIdFromIntPtr(intptr_t id) {
   return static_cast<ThreadId>(id);
 }

 bool OSThread::Compare(ThreadId a, ThreadId b) {
   return a == b;
 }

 bool OSThread::GetCurrentStackBounds(uword* lower, uword* upper) {
 // On Windows stack limits for the current thread are available in
 // the thread information block (TIB). Its fields can be accessed through
 // FS segment register on x86 and GS segment register on x86_64.
 #ifdef _WIN64
   *upper = static_cast<uword>(__readgsqword(offsetof(NT_TIB64, StackBase)));
 #else
   *upper = static_cast<uword>(__readfsdword(offsetof(NT_TIB, StackBase)));
 #endif
   // Notice that we cannot use the TIB's StackLimit for the stack end, as it
   // tracks the end of the committed range. We're after the end of the reserved
   // stack area (most of which will be uncommitted, most times).
   MEMORY_BASIC_INFORMATION stack_info;
   memset(&stack_info, 0, sizeof(MEMORY_BASIC_INFORMATION));
   size_t result_size =
       VirtualQuery(&stack_info, &stack_info, sizeof(MEMORY_BASIC_INFORMATION));
   ASSERT(result_size >= sizeof(MEMORY_BASIC_INFORMATION));
   *lower = reinterpret_cast<uword>(stack_info.AllocationBase);
   ASSERT(*upper > *lower);
   // When the third last page of the reserved stack is accessed as a
   // guard page, the second last page will be committed (along with removing
   // the guard bit on the third last) _and_ a stack overflow exception
   // is raised.
   //
   // http://blogs.msdn.com/b/satyem/archive/2012/08/13/thread-s-stack-memory-management.aspx
   // explains the details.
   ASSERT((*upper - *lower) >= (4u * 0x1000));
   *lower += 4 * 0x1000;
   return true;
 }

 #if defined(USING_SAFE_STACK)
 NO_SANITIZE_ADDRESS
 NO_SANITIZE_SAFE_STACK
 uword OSThread::GetCurrentSafestackPointer() {
 #error "SAFE_STACK is unsupported on this platform"
   return 0;
 }

 NO_SANITIZE_ADDRESS
 NO_SANITIZE_SAFE_STACK
 void OSThread::SetCurrentSafestackPointer(uword ssp) {
 #error "SAFE_STACK is unsupported on this platform"
 }
 #endif

 void OSThread::SetThreadLocal(ThreadLocalKey key, uword value) {
   ASSERT(key != kUnsetThreadLocalKey);
   BOOL result = TlsSetValue(key, reinterpret_cast<void*>(value));
   if (!result) {
     FATAL1("TlsSetValue failed %d", GetLastError());
   }
 }

 Mutex::Mutex(NOT_IN_PRODUCT(const char* name))
 #if !defined(PRODUCT)
     : name_(name)
 #endif
 {
   InitializeSRWLock(&data_.lock_);
 #if defined(DEBUG)
   // When running with assertions enabled we do track the owner.
   owner_ = OSThread::kInvalidThreadId;
 #endif  // defined(DEBUG)
 }

 Mutex::~Mutex() {
 #if defined(DEBUG)
   // When running with assertions enabled we do track the owner.
   ASSERT(owner_ == OSThread::kInvalidThreadId);
 #endif  // defined(DEBUG)
 }

 void Mutex::Lock() {
   AcquireSRWLockExclusive(&data_.lock_);
 #if defined(DEBUG)
   // When running with assertions enabled we do track the owner.
   owner_ = OSThread::GetCurrentThreadId();
 #endif  // defined(DEBUG)
 }

 bool Mutex::TryLock() {
   if (TryAcquireSRWLockExclusive(&data_.lock_) != 0) {
 #if defined(DEBUG)
     // When running with assertions enabled we do track the owner.
     owner_ = OSThread::GetCurrentThreadId();
 #endif  // defined(DEBUG)
     return true;
   }
   return false;
 }

 void Mutex::Unlock() {
 #if defined(DEBUG)
   // When running with assertions enabled we do track the owner.
   ASSERT(IsOwnedByCurrentThread());
   owner_ = OSThread::kInvalidThreadId;
 #endif  // defined(DEBUG)
   ReleaseSRWLockExclusive(&data_.lock_);
 }

 Monitor::Monitor() {
   InitializeSRWLock(&data_.lock_);
   InitializeConditionVariable(&data_.cond_);
 #if defined(DEBUG)
   // When running with assertions enabled we track the owner.
   owner_ = OSThread::kInvalidThreadId;
 #endif  // defined(DEBUG)
 }

 Monitor::~Monitor() {
 #if defined(DEBUG)
   // When running with assertions enabled we track the owner.
   ASSERT(owner_ == OSThread::kInvalidThreadId);
 #endif  // defined(DEBUG)
 }

 bool Monitor::TryEnter() {
   // Attempt to pass the semaphore but return immediately.
   if (TryAcquireSRWLockExclusive(&data_.lock_) != 0) {
 #if defined(DEBUG)
     // When running with assertions enabled we do track the owner.
     ASSERT(owner_ == OSThread::kInvalidThreadId);
     owner_ = OSThread::GetCurrentThreadId();
 #endif  // defined(DEBUG)
     return true;
   }
   return false;
 }

 void Monitor::Enter() {
   AcquireSRWLockExclusive(&data_.lock_);

 #if defined(DEBUG)
   // When running with assertions enabled we track the owner.
   ASSERT(owner_ == OSThread::kInvalidThreadId);
   owner_ = OSThread::GetCurrentThreadId();
 #endif  // defined(DEBUG)
 }

 void Monitor::Exit() {
 #if defined(DEBUG)
   // When running with assertions enabled we track the owner.
   ASSERT(IsOwnedByCurrentThread());
   owner_ = OSThread::kInvalidThreadId;
 #endif  // defined(DEBUG)

   ReleaseSRWLockExclusive(&data_.lock_);
 }

 Monitor::WaitResult Monitor::Wait(int64_t millis) {
 #if defined(DEBUG)
   // When running with assertions enabled we track the owner.
   ASSERT(IsOwnedByCurrentThread());
   ThreadId saved_owner = owner_;
   owner_ = OSThread::kInvalidThreadId;
 #endif  // defined(DEBUG)

   Monitor::WaitResult retval = kNotified;
   if (millis == kNoTimeout) {
     SleepConditionVariableSRW(&data_.cond_, &data_.lock_, INFINITE, 0);
   } else {
     // Wait for the given period of time for a Notify or a NotifyAll
     // event.
     if (!SleepConditionVariableSRW(&data_.cond_, &data_.lock_, millis, 0)) {
       ASSERT(GetLastError() == ERROR_TIMEOUT);
       retval = kTimedOut;
     }
   }

 #if defined(DEBUG)
   // When running with assertions enabled we track the owner.
   ASSERT(owner_ == OSThread::kInvalidThreadId);
   owner_ = OSThread::GetCurrentThreadId();
   ASSERT(owner_ == saved_owner);
 #endif  // defined(DEBUG)
   return retval;
 }

 Monitor::WaitResult Monitor::WaitMicros(int64_t micros) {
   // TODO(johnmccutchan): Investigate sub-millisecond sleep times on Windows.
   int64_t millis = micros / kMicrosecondsPerMillisecond;
   if ((millis * kMicrosecondsPerMillisecond) < micros) {
     // We've been asked to sleep for a fraction of a millisecond,
     // this isn't supported on Windows. Bumps milliseconds up by one
     // so that we never return too early. We likely return late though.
     millis += 1;
   }
   return Wait(millis);
 }

 void Monitor::Notify() {
   // When running with assertions enabled we track the owner.
   ASSERT(IsOwnedByCurrentThread());
   WakeConditionVariable(&data_.cond_);
 }

 void Monitor::NotifyAll() {
   // When running with assertions enabled we track the owner.
   ASSERT(IsOwnedByCurrentThread());
   WakeAllConditionVariable(&data_.cond_);
 }

 void ThreadLocalData::AddThreadLocal(ThreadLocalKey key,
                                      ThreadDestructor destructor) {
   ASSERT(thread_locals_ != NULL);
   if (destructor == NULL) {
     // We only care about thread locals with destructors.
     return;
   }
   MutexLocker ml(mutex_);
 #if defined(DEBUG)
   // Verify that we aren't added twice.
   for (intptr_t i = 0; i < thread_locals_->length(); i++) {
     const ThreadLocalEntry& entry = thread_locals_->At(i);
     ASSERT(entry.key() != key);
   }
 #endif
   // Add to list.
   thread_locals_->Add(ThreadLocalEntry(key, destructor));
 }

 void ThreadLocalData::RemoveThreadLocal(ThreadLocalKey key) {
   ASSERT(thread_locals_ != NULL);
   MutexLocker ml(mutex_);
   intptr_t i = 0;
   for (; i < thread_locals_->length(); i++) {
     const ThreadLocalEntry& entry = thread_locals_->At(i);
     if (entry.key() == key) {
       break;
     }
   }
   if (i == thread_locals_->length()) {
     // Not found.
     return;
   }
   thread_locals_->RemoveAt(i);
 }

 // This function is executed on the thread that is exiting. It is invoked
 // by |OnDartThreadExit| (see below for notes on TLS destructors on Windows).
 void ThreadLocalData::RunDestructors() {
   // If an OS thread is created but ThreadLocalData::Init has not yet been
   // called, this method still runs. If this happens, there's nothing to clean
   // up here. See issue 33826.
   if (thread_locals_ == NULL) {
     return;
   }
   ASSERT(mutex_ != NULL);
   MutexLocker ml(mutex_);
   for (intptr_t i = 0; i < thread_locals_->length(); i++) {
     const ThreadLocalEntry& entry = thread_locals_->At(i);
     // We access the exiting thread's TLS variable here.
     void* p = reinterpret_cast<void*>(OSThread::GetThreadLocal(entry.key()));
     // We invoke the constructor here.
     entry.destructor()(p);
   }
 }

 Mutex* ThreadLocalData::mutex_ = NULL;
 MallocGrowableArray<ThreadLocalEntry>* ThreadLocalData::thread_locals_ = NULL;

 void ThreadLocalData::Init() {
   mutex_ = new Mutex();
   thread_locals_ = new MallocGrowableArray<ThreadLocalEntry>();
 }

 void ThreadLocalData::Cleanup() {
   if (mutex_ != NULL) {
     delete mutex_;
     mutex_ = NULL;
   }
   if (thread_locals_ != NULL) {
     delete thread_locals_;
     thread_locals_ = NULL;
   }
 }

 }  // namespace dart

 // The following was adapted from Chromium:
 // src/base/threading/thread_local_storage_win.cc

 // Thread Termination Callbacks.
 // Windows doesn't support a per-thread destructor with its
 // TLS primitives.  So, we build it manually by inserting a
 // function to be called on each thread's exit.
 // This magic is from http://www.codeproject.com/threads/tls.asp
 // and it works for VC++ 7.0 and later.

 // Force a reference to _tls_used to make the linker create the TLS directory
 // if it's not already there.  (e.g. if __declspec(thread) is not used).
 // Force a reference to p_thread_callback_dart to prevent whole program
 // optimization from discarding the variable.
 #ifdef _WIN64

 #pragma comment(linker, "/INCLUDE:_tls_used")
 #pragma comment(linker, "/INCLUDE:p_thread_callback_dart")

 #else  // _WIN64

 #pragma comment(linker, "/INCLUDE:__tls_used")
 #pragma comment(linker, "/INCLUDE:_p_thread_callback_dart")

 #endif  // _WIN64

 // Static callback function to call with each thread termination.
 void NTAPI OnDartThreadExit(PVOID module, DWORD reason, PVOID reserved) {
   if (!dart::private_flag_windows_run_tls_destructors) {
     return;
   }
   // On XP SP0 & SP1, the DLL_PROCESS_ATTACH is never seen. It is sent on SP2+
   // and on W2K and W2K3. So don't assume it is sent.
   if (DLL_THREAD_DETACH == reason || DLL_PROCESS_DETACH == reason) {
     dart::ThreadLocalData::RunDestructors();
   }
 }

 // .CRT$XLA to .CRT$XLZ is an array of PIMAGE_TLS_CALLBACK pointers that are
 // called automatically by the OS loader code (not the CRT) when the module is
 // loaded and on thread creation. They are NOT called if the module has been
 // loaded by a LoadLibrary() call. It must have implicitly been loaded at
 // process startup.
 // By implicitly loaded, I mean that it is directly referenced by the main EXE
 // or by one of its dependent DLLs. Delay-loaded DLL doesn't count as being
 // implicitly loaded.
 //
 // See VC\crt\src\tlssup.c for reference.

 // extern "C" suppresses C++ name mangling so we know the symbol name for the
 // linker /INCLUDE:symbol pragma above.
 extern "C" {
 // The linker must not discard p_thread_callback_dart.  (We force a reference
 // to this variable with a linker /INCLUDE:symbol pragma to ensure that.) If
 // this variable is discarded, the OnDartThreadExit function will never be
 // called.
 #ifdef _WIN64

 // .CRT section is merged with .rdata on x64 so it must be constant data.
 #pragma const_seg(".CRT$XLB")
 // When defining a const variable, it must have external linkage to be sure the
 // linker doesn't discard it.
 extern const PIMAGE_TLS_CALLBACK p_thread_callback_dart;
 const PIMAGE_TLS_CALLBACK p_thread_callback_dart = OnDartThreadExit;

 // Reset the default section.
 #pragma const_seg()

 #else  // _WIN64

 #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(DART_HOST_OS_WINDOWS)
	// 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(DART_HOST_OS_WINDOWS)

	#include "vm/growable_array.h"
	#include "vm/lockers.h"
	#include "vm/os_thread.h"

	#include <process.h> // NOLINT

	#include "platform/address_sanitizer.h"
	#include "platform/assert.h"
	#include "platform/safe_stack.h"

	#include "vm/flags.h"

	namespace dart {

	DEFINE_FLAG(int,
	worker_thread_priority,
	kMinInt,
	"The thread priority the VM should use for new worker threads.");

	// 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(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) {
	if (FLAG_worker_thread_priority != kMinInt) {
	if (SetThreadPriority(GetCurrentThread(), FLAG_worker_thread_priority) ==
	0) {
	FATAL2("Setting thread priority to %d failed: GetLastError() = %d\n",
	FLAG_worker_thread_priority, GetLastError());
	}
	}

	ThreadStartData* data = reinterpret_cast<ThreadStartData*>(data_ptr);

	const char* name = data->name();
	OSThread::ThreadStartFunction function = data->function();
	uword parameter = data->parameter();
	delete data;

	// Create new OSThread object and set as TLS for new thread.
	OSThread* thread = OSThread::CreateOSThread();
	if (thread != NULL) {
	OSThread::SetCurrent(thread);
	thread->set_name(name);

	// Call the supplied thread start function handing it its parameters.
	function(parameter);
	}

	return 0;
	}

	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;
	}

	// Close the handle, so we don't leak the thread object.
	CloseHandle(reinterpret_cast<HANDLE>(thread));

	return 0;
	}

	const ThreadId OSThread::kInvalidThreadId = 0;
	const ThreadJoinId OSThread::kInvalidThreadJoinId = NULL;

	ThreadLocalKey OSThread::CreateThreadLocal(ThreadDestructor destructor) {
	ThreadLocalKey key = TlsAlloc();
	if (key == kUnsetThreadLocalKey) {
	FATAL1("TlsAlloc failed %d", GetLastError());
	}
	ThreadLocalData::AddThreadLocal(key, destructor);
	return key;
	}

	void OSThread::DeleteThreadLocal(ThreadLocalKey key) {
	ASSERT(key != kUnsetThreadLocalKey);
	BOOL result = TlsFree(key);
	if (!result) {
	FATAL1("TlsFree failed %d", GetLastError());
	}
	ThreadLocalData::RemoveThreadLocal(key);
	}

	intptr_t OSThread::GetMaxStackSize() {
	const int kStackSize = (128 * kWordSize * KB);
	return kStackSize;
	}

	ThreadId OSThread::GetCurrentThreadId() {
	return ::GetCurrentThreadId();
	}

	#ifdef SUPPORT_TIMELINE
	ThreadId OSThread::GetCurrentThreadTraceId() {
	return ::GetCurrentThreadId();
	}
	#endif // PRODUCT

	ThreadJoinId OSThread::GetCurrentThreadJoinId(OSThread* thread) {
	ASSERT(thread != NULL);
	// Make sure we're filling in the join id for the current thread.
	ThreadId id = GetCurrentThreadId();
	ASSERT(thread->id() == id);
	// Make sure the join_id_ hasn't been set, yet.
	DEBUG_ASSERT(thread->join_id_ == kInvalidThreadJoinId);
	HANDLE handle = OpenThread(SYNCHRONIZE, false, id);
	ASSERT(handle != NULL);
	#if defined(DEBUG)
	thread->join_id_ = handle;
	#endif
	return handle;
	}

	void OSThread::Join(ThreadJoinId id) {
	HANDLE handle = static_cast<HANDLE>(id);
	ASSERT(handle != NULL);
	DWORD res = WaitForSingleObject(handle, INFINITE);
	CloseHandle(handle);
	ASSERT(res == WAIT_OBJECT_0);
	}

	intptr_t OSThread::ThreadIdToIntPtr(ThreadId id) {
	ASSERT(sizeof(id) <= sizeof(intptr_t));
	return static_cast<intptr_t>(id);
	}

	ThreadId OSThread::ThreadIdFromIntPtr(intptr_t id) {
	return static_cast<ThreadId>(id);
	}

	bool OSThread::Compare(ThreadId a, ThreadId b) {
	return a == b;
	}

	bool OSThread::GetCurrentStackBounds(uword* lower, uword* upper) {
	// On Windows stack limits for the current thread are available in
	// the thread information block (TIB). Its fields can be accessed through
	// FS segment register on x86 and GS segment register on x86_64.
	#ifdef _WIN64
	*upper = static_cast<uword>(__readgsqword(offsetof(NT_TIB64, StackBase)));
	#else
	*upper = static_cast<uword>(__readfsdword(offsetof(NT_TIB, StackBase)));
	#endif
	// Notice that we cannot use the TIB's StackLimit for the stack end, as it
	// tracks the end of the committed range. We're after the end of the reserved
	// stack area (most of which will be uncommitted, most times).
	MEMORY_BASIC_INFORMATION stack_info;
	memset(&stack_info, 0, sizeof(MEMORY_BASIC_INFORMATION));
	size_t result_size =
	VirtualQuery(&stack_info, &stack_info, sizeof(MEMORY_BASIC_INFORMATION));
	ASSERT(result_size >= sizeof(MEMORY_BASIC_INFORMATION));
	*lower = reinterpret_cast<uword>(stack_info.AllocationBase);
	ASSERT(upper > lower);
	// When the third last page of the reserved stack is accessed as a
	// guard page, the second last page will be committed (along with removing
	// the guard bit on the third last) _and_ a stack overflow exception
	// is raised.
	//
	// http://blogs.msdn.com/b/satyem/archive/2012/08/13/thread-s-stack-memory-management.aspx
	// explains the details.
	ASSERT((upper - lower) >= (4u * 0x1000));
	lower += 4 0x1000;
	return true;
	}

	#if defined(USING_SAFE_STACK)
	NO_SANITIZE_ADDRESS
	NO_SANITIZE_SAFE_STACK
	uword OSThread::GetCurrentSafestackPointer() {
	#error "SAFE_STACK is unsupported on this platform"
	return 0;
	}

	NO_SANITIZE_ADDRESS
	NO_SANITIZE_SAFE_STACK
	void OSThread::SetCurrentSafestackPointer(uword ssp) {
	#error "SAFE_STACK is unsupported on this platform"
	}
	#endif

	void OSThread::SetThreadLocal(ThreadLocalKey key, uword value) {
	ASSERT(key != kUnsetThreadLocalKey);
	BOOL result = TlsSetValue(key, reinterpret_cast<void*>(value));
	if (!result) {
	FATAL1("TlsSetValue failed %d", GetLastError());
	}
	}

	Mutex::Mutex(NOT_IN_PRODUCT(const char* name))
	#if !defined(PRODUCT)
	: name_(name)
	#endif
	{
	InitializeSRWLock(&data_.lock_);
	#if defined(DEBUG)
	// When running with assertions enabled we do track the owner.
	owner_ = OSThread::kInvalidThreadId;
	#endif // defined(DEBUG)
	}

	Mutex::~Mutex() {
	#if defined(DEBUG)
	// When running with assertions enabled we do track the owner.
	ASSERT(owner_ == OSThread::kInvalidThreadId);
	#endif // defined(DEBUG)
	}

	void Mutex::Lock() {
	AcquireSRWLockExclusive(&data_.lock_);
	#if defined(DEBUG)
	// When running with assertions enabled we do track the owner.
	owner_ = OSThread::GetCurrentThreadId();
	#endif // defined(DEBUG)
	}

	bool Mutex::TryLock() {
	if (TryAcquireSRWLockExclusive(&data_.lock_) != 0) {
	#if defined(DEBUG)
	// When running with assertions enabled we do track the owner.
	owner_ = OSThread::GetCurrentThreadId();
	#endif // defined(DEBUG)
	return true;
	}
	return false;
	}

	void Mutex::Unlock() {
	#if defined(DEBUG)
	// When running with assertions enabled we do track the owner.
	ASSERT(IsOwnedByCurrentThread());
	owner_ = OSThread::kInvalidThreadId;
	#endif // defined(DEBUG)
	ReleaseSRWLockExclusive(&data_.lock_);
	}

	Monitor::Monitor() {
	InitializeSRWLock(&data_.lock_);
	InitializeConditionVariable(&data_.cond_);
	#if defined(DEBUG)
	// When running with assertions enabled we track the owner.
	owner_ = OSThread::kInvalidThreadId;
	#endif // defined(DEBUG)
	}

	Monitor::~Monitor() {
	#if defined(DEBUG)
	// When running with assertions enabled we track the owner.
	ASSERT(owner_ == OSThread::kInvalidThreadId);
	#endif // defined(DEBUG)
	}

	bool Monitor::TryEnter() {
	// Attempt to pass the semaphore but return immediately.
	if (TryAcquireSRWLockExclusive(&data_.lock_) != 0) {
	#if defined(DEBUG)
	// When running with assertions enabled we do track the owner.
	ASSERT(owner_ == OSThread::kInvalidThreadId);
	owner_ = OSThread::GetCurrentThreadId();
	#endif // defined(DEBUG)
	return true;
	}
	return false;
	}

	void Monitor::Enter() {
	AcquireSRWLockExclusive(&data_.lock_);

	#if defined(DEBUG)
	// When running with assertions enabled we track the owner.
	ASSERT(owner_ == OSThread::kInvalidThreadId);
	owner_ = OSThread::GetCurrentThreadId();
	#endif // defined(DEBUG)
	}

	void Monitor::Exit() {
	#if defined(DEBUG)
	// When running with assertions enabled we track the owner.
	ASSERT(IsOwnedByCurrentThread());
	owner_ = OSThread::kInvalidThreadId;
	#endif // defined(DEBUG)

	ReleaseSRWLockExclusive(&data_.lock_);
	}

	Monitor::WaitResult Monitor::Wait(int64_t millis) {
	#if defined(DEBUG)
	// When running with assertions enabled we track the owner.
	ASSERT(IsOwnedByCurrentThread());
	ThreadId saved_owner = owner_;
	owner_ = OSThread::kInvalidThreadId;
	#endif // defined(DEBUG)

	Monitor::WaitResult retval = kNotified;
	if (millis == kNoTimeout) {
	SleepConditionVariableSRW(&data_.cond_, &data_.lock_, INFINITE, 0);
	} else {
	// Wait for the given period of time for a Notify or a NotifyAll
	// event.
	if (!SleepConditionVariableSRW(&data_.cond_, &data_.lock_, millis, 0)) {
	ASSERT(GetLastError() == ERROR_TIMEOUT);
	retval = kTimedOut;
	}
	}

	#if defined(DEBUG)
	// When running with assertions enabled we track the owner.
	ASSERT(owner_ == OSThread::kInvalidThreadId);
	owner_ = OSThread::GetCurrentThreadId();
	ASSERT(owner_ == saved_owner);
	#endif // defined(DEBUG)
	return retval;
	}

	Monitor::WaitResult Monitor::WaitMicros(int64_t micros) {
	// TODO(johnmccutchan): Investigate sub-millisecond sleep times on Windows.
	int64_t millis = micros / kMicrosecondsPerMillisecond;
	if ((millis * kMicrosecondsPerMillisecond) < micros) {
	// We've been asked to sleep for a fraction of a millisecond,
	// this isn't supported on Windows. Bumps milliseconds up by one
	// so that we never return too early. We likely return late though.
	millis += 1;
	}
	return Wait(millis);
	}

	void Monitor::Notify() {
	// When running with assertions enabled we track the owner.
	ASSERT(IsOwnedByCurrentThread());
	WakeConditionVariable(&data_.cond_);
	}

	void Monitor::NotifyAll() {
	// When running with assertions enabled we track the owner.
	ASSERT(IsOwnedByCurrentThread());
	WakeAllConditionVariable(&data_.cond_);
	}

	void ThreadLocalData::AddThreadLocal(ThreadLocalKey key,
	ThreadDestructor destructor) {
	ASSERT(thread_locals_ != NULL);
	if (destructor == NULL) {
	// We only care about thread locals with destructors.
	return;
	}
	MutexLocker ml(mutex_);
	#if defined(DEBUG)
	// Verify that we aren't added twice.
	for (intptr_t i = 0; i < thread_locals_->length(); i++) {
	const ThreadLocalEntry& entry = thread_locals_->At(i);
	ASSERT(entry.key() != key);
	}
	#endif
	// Add to list.
	thread_locals_->Add(ThreadLocalEntry(key, destructor));
	}

	void ThreadLocalData::RemoveThreadLocal(ThreadLocalKey key) {
	ASSERT(thread_locals_ != NULL);
	MutexLocker ml(mutex_);
	intptr_t i = 0;
	for (; i < thread_locals_->length(); i++) {
	const ThreadLocalEntry& entry = thread_locals_->At(i);
	if (entry.key() == key) {
	break;
	}
	}
	if (i == thread_locals_->length()) {
	// Not found.
	return;
	}
	thread_locals_->RemoveAt(i);
	}

	// This function is executed on the thread that is exiting. It is invoked
	// by \|OnDartThreadExit\| (see below for notes on TLS destructors on Windows).
	void ThreadLocalData::RunDestructors() {
	// If an OS thread is created but ThreadLocalData::Init has not yet been
	// called, this method still runs. If this happens, there's nothing to clean
	// up here. See issue 33826.
	if (thread_locals_ == NULL) {
	return;
	}
	ASSERT(mutex_ != NULL);
	MutexLocker ml(mutex_);
	for (intptr_t i = 0; i < thread_locals_->length(); i++) {
	const ThreadLocalEntry& entry = thread_locals_->At(i);
	// We access the exiting thread's TLS variable here.
	void* p = reinterpret_cast<void*>(OSThread::GetThreadLocal(entry.key()));
	// We invoke the constructor here.
	entry.destructor()(p);
	}
	}

	Mutex* ThreadLocalData::mutex_ = NULL;
	MallocGrowableArray<ThreadLocalEntry>* ThreadLocalData::thread_locals_ = NULL;

	void ThreadLocalData::Init() {
	mutex_ = new Mutex();
	thread_locals_ = new MallocGrowableArray<ThreadLocalEntry>();
	}

	void ThreadLocalData::Cleanup() {
	if (mutex_ != NULL) {
	delete mutex_;
	mutex_ = NULL;
	}
	if (thread_locals_ != NULL) {
	delete thread_locals_;
	thread_locals_ = NULL;
	}
	}

	} // namespace dart

	// The following was adapted from Chromium:
	// src/base/threading/thread_local_storage_win.cc

	// Thread Termination Callbacks.
	// Windows doesn't support a per-thread destructor with its
	// TLS primitives. So, we build it manually by inserting a
	// function to be called on each thread's exit.
	// This magic is from http://www.codeproject.com/threads/tls.asp
	// and it works for VC++ 7.0 and later.

	// Force a reference to _tls_used to make the linker create the TLS directory
	// if it's not already there. (e.g. if __declspec(thread) is not used).
	// Force a reference to p_thread_callback_dart to prevent whole program
	// optimization from discarding the variable.
	#ifdef _WIN64

	#pragma comment(linker, "/INCLUDE:_tls_used")
	#pragma comment(linker, "/INCLUDE:p_thread_callback_dart")

	#else // _WIN64

	#pragma comment(linker, "/INCLUDE:__tls_used")
	#pragma comment(linker, "/INCLUDE:_p_thread_callback_dart")

	#endif // _WIN64

	// Static callback function to call with each thread termination.
	void NTAPI OnDartThreadExit(PVOID module, DWORD reason, PVOID reserved) {
	if (!dart::private_flag_windows_run_tls_destructors) {
	return;
	}
	// On XP SP0 & SP1, the DLL_PROCESS_ATTACH is never seen. It is sent on SP2+
	// and on W2K and W2K3. So don't assume it is sent.
	if (DLL_THREAD_DETACH == reason \|\| DLL_PROCESS_DETACH == reason) {
	dart::ThreadLocalData::RunDestructors();
	}
	}

	// .CRT$XLA to .CRT$XLZ is an array of PIMAGE_TLS_CALLBACK pointers that are
	// called automatically by the OS loader code (not the CRT) when the module is
	// loaded and on thread creation. They are NOT called if the module has been
	// loaded by a LoadLibrary() call. It must have implicitly been loaded at
	// process startup.
	// By implicitly loaded, I mean that it is directly referenced by the main EXE
	// or by one of its dependent DLLs. Delay-loaded DLL doesn't count as being
	// implicitly loaded.
	//
	// See VC\crt\src\tlssup.c for reference.

	// extern "C" suppresses C++ name mangling so we know the symbol name for the
	// linker /INCLUDE:symbol pragma above.
	extern "C" {
	// The linker must not discard p_thread_callback_dart. (We force a reference
	// to this variable with a linker /INCLUDE:symbol pragma to ensure that.) If
	// this variable is discarded, the OnDartThreadExit function will never be
	// called.
	#ifdef _WIN64

	// .CRT section is merged with .rdata on x64 so it must be constant data.
	#pragma const_seg(".CRT$XLB")
	// When defining a const variable, it must have external linkage to be sure the
	// linker doesn't discard it.
	extern const PIMAGE_TLS_CALLBACK p_thread_callback_dart;
	const PIMAGE_TLS_CALLBACK p_thread_callback_dart = OnDartThreadExit;

	// Reset the default section.
	#pragma const_seg()

	#else // _WIN64

	#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(DART_HOST_OS_WINDOWS)