mirror of
https://github.com/dart-lang/sdk
synced 2024-09-05 00:13:50 +00:00
![Matthew Dempsky](/assets/img/avatar_default.png)
In many cases, the Mutexes and Monitors have to be marked "mutable" because they're used to synchronize const accessor methods. Small text segment improvement for Product builds: $ size dart.{arm,x64}.{before,after} text data bss dec hex filename 19726069 409960 392332 20528361 1393ce9 dart.arm.before 19725525 409960 392332 20527817 1393ac9 dart.arm.after 22576021 600376 1782824 24959221 17cd8f5 dart.x64.before 22574821 600376 1782824 24958021 17cd445 dart.x64.after Change-Id: I68f5cd5ad452044df8bfebd160910496036a3e6b Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/101745 Commit-Queue: Matthew Dempsky <mdempsky@google.com> Reviewed-by: Vyacheslav Egorov <vegorov@google.com>
323 lines
9.2 KiB
C++
323 lines
9.2 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/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;
|
|
|
|
#if defined(HAS_C11_THREAD_LOCAL)
|
|
thread_local ThreadState* OSThread::current_vm_thread_ = NULL;
|
|
#endif
|
|
|
|
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_)) {
|
|
// Fall back to a guess based on the stack pointer.
|
|
RefineStackBoundsFromSP(GetCurrentStackPointer());
|
|
}
|
|
|
|
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);
|
|
AtomicOperations::FetchAndIncrement(&thread_interrupt_disabled_);
|
|
}
|
|
|
|
void OSThread::EnableThreadInterrupts() {
|
|
ASSERT(OSThread::Current() == this);
|
|
uintptr_t old =
|
|
AtomicOperations::FetchAndDecrement(&thread_interrupt_disabled_);
|
|
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 AtomicOperations::LoadRelaxed(&thread_interrupt_disabled_) == 0;
|
|
}
|
|
|
|
static void DeleteThread(void* 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));
|
|
|
|
#if defined(HAS_C11_THREAD_LOCAL)
|
|
// 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;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
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
|