blob: 6fe6746a8d139d4da00392576911b333e07a6889 [file] [log] [blame] [edit]
// 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/thread_registry.h"
#include "vm/json_stream.h"
#include "vm/lockers.h"
namespace dart {
ThreadRegistry::~ThreadRegistry() {
// Go over the free thread list and delete the thread objects.
{
MonitorLocker ml(threads_lock());
// At this point the active list should be empty.
ASSERT(active_list_ == nullptr);
// Now delete all the threads in the free list.
while (free_list_ != nullptr) {
Thread* thread = free_list_;
free_list_ = thread->next_;
delete thread;
}
}
}
Thread* ThreadRegistry::GetFreeThreadLocked(bool is_vm_isolate) {
ASSERT(threads_lock()->IsOwnedByCurrentThread());
Thread* thread = GetFromFreelistLocked(is_vm_isolate);
ASSERT(thread->api_top_scope() == nullptr);
// Now add this Thread to the active list for the isolate.
AddToActiveListLocked(thread);
return thread;
}
void ThreadRegistry::ReturnThreadLocked(Thread* thread) {
ASSERT(threads_lock()->IsOwnedByCurrentThread());
// Remove thread from the active list for the isolate.
RemoveFromActiveListLocked(thread);
ReturnToFreelistLocked(thread);
}
void ThreadRegistry::VisitObjectPointers(
IsolateGroup* isolate_group_of_interest,
ObjectPointerVisitor* visitor,
ValidationPolicy validate_frames) {
MonitorLocker ml(threads_lock());
Thread* thread = active_list_;
while (thread != nullptr) {
if (thread->isolate_group() == isolate_group_of_interest) {
// The mutator thread is visited by the isolate itself (see
// [IsolateGroup::VisitStackPointers]).
if (!thread->IsDartMutatorThread()) {
thread->VisitObjectPointers(visitor, validate_frames);
}
}
thread = thread->next_;
}
}
void ThreadRegistry::ForEachThread(
std::function<void(Thread* thread)> callback) {
MonitorLocker ml(threads_lock());
Thread* thread = active_list_;
while (thread != nullptr) {
callback(thread);
thread = thread->next_;
}
}
void ThreadRegistry::ReleaseStoreBuffers() {
MonitorLocker ml(threads_lock());
Thread* thread = active_list_;
while (thread != nullptr) {
if (!thread->BypassSafepoints()) {
thread->ReleaseStoreBuffer();
}
thread = thread->next_;
}
}
void ThreadRegistry::AcquireMarkingStacks() {
MonitorLocker ml(threads_lock());
Thread* thread = active_list_;
while (thread != nullptr) {
if (!thread->BypassSafepoints()) {
thread->AcquireMarkingStacks();
}
thread = thread->next_;
}
}
void ThreadRegistry::ReleaseMarkingStacks() {
MonitorLocker ml(threads_lock());
Thread* thread = active_list_;
while (thread != nullptr) {
if (!thread->BypassSafepoints()) {
thread->ReleaseMarkingStacks();
ASSERT(!thread->is_marking());
}
thread = thread->next_;
}
}
void ThreadRegistry::FlushMarkingStacks() {
MonitorLocker ml(threads_lock());
Thread* thread = active_list_;
while (thread != nullptr) {
if (!thread->BypassSafepoints() && thread->is_marking()) {
thread->FlushMarkingStacks();
ASSERT(thread->is_marking());
}
thread = thread->next_;
}
}
void ThreadRegistry::AddToActiveListLocked(Thread* thread) {
ASSERT(thread != nullptr);
ASSERT(threads_lock()->IsOwnedByCurrentThread());
thread->next_ = active_list_;
active_list_ = thread;
active_isolates_count_.fetch_add(1);
}
void ThreadRegistry::RemoveFromActiveListLocked(Thread* thread) {
ASSERT(thread != nullptr);
ASSERT(threads_lock()->IsOwnedByCurrentThread());
Thread* prev = nullptr;
Thread* current = active_list_;
while (current != nullptr) {
if (current == thread) {
if (prev == nullptr) {
active_list_ = current->next_;
} else {
prev->next_ = current->next_;
}
active_isolates_count_.fetch_sub(1);
break;
}
prev = current;
current = current->next_;
}
}
Thread* ThreadRegistry::GetFromFreelistLocked(bool is_vm_isolate) {
ASSERT(threads_lock()->IsOwnedByCurrentThread());
Thread* thread = nullptr;
// Get thread structure from free list or create a new one.
if (free_list_ == nullptr) {
thread = new Thread(is_vm_isolate);
} else {
thread = free_list_;
free_list_ = thread->next_;
}
return thread;
}
void ThreadRegistry::ReturnToFreelistLocked(Thread* thread) {
ASSERT(thread != nullptr);
ASSERT(thread->os_thread() == nullptr);
ASSERT(thread->isolate_ == nullptr);
ASSERT(thread->isolate_group_ == nullptr);
ASSERT(thread->field_table_values_ == nullptr);
ASSERT(thread->shared_field_table_values_ == nullptr);
ASSERT(threads_lock()->IsOwnedByCurrentThread());
// Add thread to the free list.
thread->next_ = free_list_;
free_list_ = thread;
}
} // namespace dart