mirror of
https://github.com/dart-lang/sdk
synced 2024-09-05 00:13:50 +00:00
![Ryan Macnak](/assets/img/avatar_default.png)
Thus requiring iOS 9+. TEST=build Change-Id: I40062753ae030231d4e4ae428c9145f4370cb9a0 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/213283 Commit-Queue: Ryan Macnak <rmacnak@google.com> Reviewed-by: Chinmay Garde <chinmaygarde@google.com>
319 lines
9 KiB
C++
319 lines
9 KiB
C++
// 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/os_thread.h"
|
|
|
|
#include "platform/address_sanitizer.h"
|
|
#include "platform/atomic.h"
|
|
#include "vm/lockers.h"
|
|
#include "vm/log.h"
|
|
#include "vm/thread_interrupter.h"
|
|
#include "vm/timeline.h"
|
|
|
|
namespace dart {
|
|
|
|
// The single thread local key which stores all the thread local data
|
|
// for a thread.
|
|
ThreadLocalKey OSThread::thread_key_ = kUnsetThreadLocalKey;
|
|
OSThread* OSThread::thread_list_head_ = NULL;
|
|
Mutex* OSThread::thread_list_lock_ = NULL;
|
|
bool OSThread::creation_enabled_ = false;
|
|
|
|
thread_local ThreadState* OSThread::current_vm_thread_ = NULL;
|
|
|
|
OSThread::OSThread()
|
|
: BaseThread(true),
|
|
id_(OSThread::GetCurrentThreadId()),
|
|
#if defined(DEBUG)
|
|
join_id_(kInvalidThreadJoinId),
|
|
#endif
|
|
#ifdef SUPPORT_TIMELINE
|
|
trace_id_(OSThread::GetCurrentThreadTraceId()),
|
|
#endif
|
|
name_(NULL),
|
|
timeline_block_lock_(),
|
|
timeline_block_(NULL),
|
|
thread_list_next_(NULL),
|
|
thread_interrupt_disabled_(1), // Thread interrupts disabled by default.
|
|
log_(new class Log()),
|
|
stack_base_(0),
|
|
stack_limit_(0),
|
|
stack_headroom_(0),
|
|
thread_(NULL) {
|
|
// Try to get accurate stack bounds from pthreads, etc.
|
|
if (!GetCurrentStackBounds(&stack_limit_, &stack_base_)) {
|
|
FATAL("Failed to retrieve stack bounds");
|
|
}
|
|
|
|
stack_headroom_ = CalculateHeadroom(stack_base_ - stack_limit_);
|
|
|
|
ASSERT(stack_base_ != 0);
|
|
ASSERT(stack_limit_ != 0);
|
|
ASSERT(stack_base_ > stack_limit_);
|
|
ASSERT(stack_base_ > GetCurrentStackPointer());
|
|
ASSERT(stack_limit_ < GetCurrentStackPointer());
|
|
RELEASE_ASSERT(HasStackHeadroom());
|
|
}
|
|
|
|
OSThread* OSThread::CreateOSThread() {
|
|
ASSERT(thread_list_lock_ != NULL);
|
|
MutexLocker ml(thread_list_lock_);
|
|
if (!creation_enabled_) {
|
|
return NULL;
|
|
}
|
|
OSThread* os_thread = new OSThread();
|
|
AddThreadToListLocked(os_thread);
|
|
return os_thread;
|
|
}
|
|
|
|
OSThread::~OSThread() {
|
|
if (!is_os_thread()) {
|
|
// If the embedder enters an isolate on this thread and does not exit the
|
|
// isolate, the thread local at thread_key_, which we are destructing here,
|
|
// will contain a dart::Thread instead of a dart::OSThread.
|
|
FATAL("Thread exited without calling Dart_ExitIsolate");
|
|
}
|
|
RemoveThreadFromList(this);
|
|
delete log_;
|
|
log_ = NULL;
|
|
#if defined(SUPPORT_TIMELINE)
|
|
if (Timeline::recorder() != NULL) {
|
|
Timeline::recorder()->FinishBlock(timeline_block_);
|
|
}
|
|
#endif
|
|
timeline_block_ = NULL;
|
|
free(name_);
|
|
}
|
|
|
|
void OSThread::SetName(const char* name) {
|
|
MutexLocker ml(thread_list_lock_);
|
|
// Clear the old thread name.
|
|
if (name_ != NULL) {
|
|
free(name_);
|
|
name_ = NULL;
|
|
}
|
|
set_name(name);
|
|
}
|
|
|
|
// Disable AdressSanitizer and SafeStack transformation on this function. In
|
|
// particular, taking the address of a local gives an address on the stack
|
|
// instead of an address in the shadow memory (AddressSanitizer) or the safe
|
|
// stack (SafeStack).
|
|
NO_SANITIZE_ADDRESS
|
|
NO_SANITIZE_SAFE_STACK
|
|
DART_NOINLINE
|
|
uword OSThread::GetCurrentStackPointer() {
|
|
uword stack_allocated_local = reinterpret_cast<uword>(&stack_allocated_local);
|
|
return stack_allocated_local;
|
|
}
|
|
|
|
void OSThread::DisableThreadInterrupts() {
|
|
ASSERT(OSThread::Current() == this);
|
|
thread_interrupt_disabled_.fetch_add(1u);
|
|
}
|
|
|
|
void OSThread::EnableThreadInterrupts() {
|
|
ASSERT(OSThread::Current() == this);
|
|
uintptr_t old = thread_interrupt_disabled_.fetch_sub(1u);
|
|
if (FLAG_profiler && (old == 1)) {
|
|
// We just decremented from 1 to 0.
|
|
// Make sure the thread interrupter is awake.
|
|
ThreadInterrupter::WakeUp();
|
|
}
|
|
if (old == 0) {
|
|
// We just decremented from 0, this means we've got a mismatched pair
|
|
// of calls to EnableThreadInterrupts and DisableThreadInterrupts.
|
|
FATAL("Invalid call to OSThread::EnableThreadInterrupts()");
|
|
}
|
|
}
|
|
|
|
bool OSThread::ThreadInterruptsEnabled() {
|
|
return thread_interrupt_disabled_ == 0;
|
|
}
|
|
|
|
static void DeleteThread(void* thread) {
|
|
MSAN_UNPOISON(&thread, sizeof(thread));
|
|
delete reinterpret_cast<OSThread*>(thread);
|
|
}
|
|
|
|
void OSThread::Init() {
|
|
// Allocate the global OSThread lock.
|
|
if (thread_list_lock_ == NULL) {
|
|
thread_list_lock_ = new Mutex();
|
|
}
|
|
ASSERT(thread_list_lock_ != NULL);
|
|
|
|
// Create the thread local key.
|
|
if (thread_key_ == kUnsetThreadLocalKey) {
|
|
thread_key_ = CreateThreadLocal(DeleteThread);
|
|
}
|
|
ASSERT(thread_key_ != kUnsetThreadLocalKey);
|
|
|
|
// Enable creation of OSThread structures in the VM.
|
|
EnableOSThreadCreation();
|
|
|
|
// Create a new OSThread strcture and set it as the TLS.
|
|
OSThread* os_thread = CreateOSThread();
|
|
ASSERT(os_thread != NULL);
|
|
OSThread::SetCurrent(os_thread);
|
|
os_thread->set_name("Dart_Initialize");
|
|
}
|
|
|
|
void OSThread::Cleanup() {
|
|
// We cannot delete the thread local key and thread list lock, yet.
|
|
// See the note on thread_list_lock_ in os_thread.h.
|
|
#if 0
|
|
if (thread_list_lock_ != NULL) {
|
|
// Delete the thread local key.
|
|
ASSERT(thread_key_ != kUnsetThreadLocalKey);
|
|
DeleteThreadLocal(thread_key_);
|
|
thread_key_ = kUnsetThreadLocalKey;
|
|
|
|
// Delete the global OSThread lock.
|
|
ASSERT(thread_list_lock_ != NULL);
|
|
delete thread_list_lock_;
|
|
thread_list_lock_ = NULL;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
OSThread* OSThread::CreateAndSetUnknownThread() {
|
|
ASSERT(OSThread::GetCurrentTLS() == NULL);
|
|
OSThread* os_thread = CreateOSThread();
|
|
if (os_thread != NULL) {
|
|
OSThread::SetCurrent(os_thread);
|
|
os_thread->set_name("Unknown");
|
|
}
|
|
return os_thread;
|
|
}
|
|
|
|
bool OSThread::IsThreadInList(ThreadId id) {
|
|
if (id == OSThread::kInvalidThreadId) {
|
|
return false;
|
|
}
|
|
OSThreadIterator it;
|
|
while (it.HasNext()) {
|
|
ASSERT(OSThread::thread_list_lock_->IsOwnedByCurrentThread());
|
|
OSThread* t = it.Next();
|
|
// An address test is not sufficient because the allocator may recycle
|
|
// the address for another Thread. Test against the thread's id.
|
|
if (t->id() == id) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void OSThread::DisableOSThreadCreation() {
|
|
MutexLocker ml(thread_list_lock_);
|
|
creation_enabled_ = false;
|
|
}
|
|
|
|
void OSThread::EnableOSThreadCreation() {
|
|
MutexLocker ml(thread_list_lock_);
|
|
creation_enabled_ = true;
|
|
}
|
|
|
|
OSThread* OSThread::GetOSThreadFromThread(ThreadState* thread) {
|
|
ASSERT(thread->os_thread() != NULL);
|
|
return thread->os_thread();
|
|
}
|
|
|
|
void OSThread::AddThreadToListLocked(OSThread* thread) {
|
|
ASSERT(thread != NULL);
|
|
ASSERT(thread_list_lock_ != NULL);
|
|
ASSERT(OSThread::thread_list_lock_->IsOwnedByCurrentThread());
|
|
ASSERT(creation_enabled_);
|
|
ASSERT(thread->thread_list_next_ == NULL);
|
|
|
|
#if defined(DEBUG)
|
|
{
|
|
// Ensure that we aren't already in the list.
|
|
OSThread* current = thread_list_head_;
|
|
while (current != NULL) {
|
|
ASSERT(current != thread);
|
|
current = current->thread_list_next_;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// Insert at head of list.
|
|
thread->thread_list_next_ = thread_list_head_;
|
|
thread_list_head_ = thread;
|
|
}
|
|
|
|
void OSThread::RemoveThreadFromList(OSThread* thread) {
|
|
bool final_thread = false;
|
|
{
|
|
ASSERT(thread != NULL);
|
|
ASSERT(thread_list_lock_ != NULL);
|
|
MutexLocker ml(thread_list_lock_);
|
|
OSThread* current = thread_list_head_;
|
|
OSThread* previous = NULL;
|
|
|
|
// Scan across list and remove |thread|.
|
|
while (current != NULL) {
|
|
if (current == thread) {
|
|
// We found |thread|, remove from list.
|
|
if (previous == NULL) {
|
|
thread_list_head_ = thread->thread_list_next_;
|
|
} else {
|
|
previous->thread_list_next_ = current->thread_list_next_;
|
|
}
|
|
thread->thread_list_next_ = NULL;
|
|
final_thread = !creation_enabled_ && (thread_list_head_ == NULL);
|
|
break;
|
|
}
|
|
previous = current;
|
|
current = current->thread_list_next_;
|
|
}
|
|
}
|
|
// Check if this is the last thread. The last thread does a cleanup
|
|
// which removes the thread local key and the associated mutex.
|
|
if (final_thread) {
|
|
Cleanup();
|
|
}
|
|
}
|
|
|
|
void OSThread::SetCurrentTLS(BaseThread* value) {
|
|
// Provides thread-local destructors.
|
|
SetThreadLocal(thread_key_, reinterpret_cast<uword>(value));
|
|
|
|
// Allows the C compiler more freedom to optimize.
|
|
if ((value != NULL) && !value->is_os_thread()) {
|
|
current_vm_thread_ = static_cast<Thread*>(value);
|
|
} else {
|
|
current_vm_thread_ = NULL;
|
|
}
|
|
}
|
|
|
|
OSThreadIterator::OSThreadIterator() {
|
|
ASSERT(OSThread::thread_list_lock_ != NULL);
|
|
// Lock the thread list while iterating.
|
|
OSThread::thread_list_lock_->Lock();
|
|
next_ = OSThread::thread_list_head_;
|
|
}
|
|
|
|
OSThreadIterator::~OSThreadIterator() {
|
|
ASSERT(OSThread::thread_list_lock_ != NULL);
|
|
// Unlock the thread list when done.
|
|
OSThread::thread_list_lock_->Unlock();
|
|
}
|
|
|
|
bool OSThreadIterator::HasNext() const {
|
|
ASSERT(OSThread::thread_list_lock_ != NULL);
|
|
ASSERT(OSThread::thread_list_lock_->IsOwnedByCurrentThread());
|
|
return next_ != NULL;
|
|
}
|
|
|
|
OSThread* OSThreadIterator::Next() {
|
|
ASSERT(OSThread::thread_list_lock_ != NULL);
|
|
ASSERT(OSThread::thread_list_lock_->IsOwnedByCurrentThread());
|
|
OSThread* current = next_;
|
|
next_ = next_->thread_list_next_;
|
|
return current;
|
|
}
|
|
|
|
} // namespace dart
|