mirror of
https://github.com/dart-lang/sdk
synced 2024-09-05 00:13:50 +00:00
![Martin Kustermann](/assets/img/avatar_default.png)
This CL moves the thread registry and the safepoint handler to the [IsolateGroup]. This will cause all threads belonging to the isolate group to safepoint together. => We will therefore start to get an idea of the impact this will have on pause times. So far it was only possible to enter a particular isolate (e.g. as mutator thread or auxiliary thread). This CL adds support for entering an isolate group (instead of a particular isolate) as an auxiliarly thread. The current isolate group is available via `IsolateGroup::Current()`. => This is a preparation step to let GC threads enter the isolate group as auxiliary threads, not associated with a particular isolate but to an isolate group as a whole. Issue https://github.com/dart-lang/sdk/issues/36097 Change-Id: I7069d07130938d370869f02060570143bfeb1b48 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/108801 Reviewed-by: Ryan Macnak <rmacnak@google.com> Commit-Queue: Martin Kustermann <kustermann@google.com>
192 lines
5.3 KiB
C++
192 lines
5.3 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/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_ == NULL);
|
|
|
|
// Now delete all the threads in the free list.
|
|
while (free_list_ != NULL) {
|
|
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() == NULL);
|
|
// 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(Isolate* isolate_of_interest,
|
|
ObjectPointerVisitor* visitor,
|
|
ValidationPolicy validate_frames) {
|
|
MonitorLocker ml(threads_lock());
|
|
Thread* thread = active_list_;
|
|
while (thread != NULL) {
|
|
if (thread->isolate() == isolate_of_interest) {
|
|
// The mutator thread is visited by the isolate itself (see
|
|
// [Isolate::VisitStackPointers]).
|
|
if (!thread->IsMutatorThread()) {
|
|
thread->VisitObjectPointers(visitor, validate_frames);
|
|
}
|
|
}
|
|
thread = thread->next_;
|
|
}
|
|
}
|
|
|
|
void ThreadRegistry::ReleaseStoreBuffers(Isolate* isolate_of_interest) {
|
|
MonitorLocker ml(threads_lock());
|
|
Thread* thread = active_list_;
|
|
while (thread != NULL) {
|
|
if (thread->isolate() == isolate_of_interest) {
|
|
if (!thread->BypassSafepoints()) {
|
|
thread->ReleaseStoreBuffer();
|
|
}
|
|
}
|
|
thread = thread->next_;
|
|
}
|
|
}
|
|
|
|
void ThreadRegistry::AcquireMarkingStacks(Isolate* isolate_of_interest) {
|
|
MonitorLocker ml(threads_lock());
|
|
Thread* thread = active_list_;
|
|
while (thread != NULL) {
|
|
if (thread->isolate() == isolate_of_interest) {
|
|
if (!thread->BypassSafepoints()) {
|
|
thread->MarkingStackAcquire();
|
|
thread->DeferredMarkingStackAcquire();
|
|
}
|
|
}
|
|
thread = thread->next_;
|
|
}
|
|
}
|
|
|
|
void ThreadRegistry::ReleaseMarkingStacks(Isolate* isolate_of_interest) {
|
|
MonitorLocker ml(threads_lock());
|
|
Thread* thread = active_list_;
|
|
while (thread != NULL) {
|
|
if (thread->isolate() == isolate_of_interest) {
|
|
if (!thread->BypassSafepoints()) {
|
|
thread->MarkingStackRelease();
|
|
thread->DeferredMarkingStackRelease();
|
|
}
|
|
}
|
|
thread = thread->next_;
|
|
}
|
|
}
|
|
|
|
#ifndef PRODUCT
|
|
void ThreadRegistry::PrintJSON(JSONStream* stream) const {
|
|
MonitorLocker ml(threads_lock());
|
|
JSONArray threads(stream);
|
|
Thread* current = active_list_;
|
|
while (current != NULL) {
|
|
threads.AddValue(current);
|
|
current = current->next_;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
intptr_t ThreadRegistry::CountZoneHandles(Isolate* isolate_of_interest) const {
|
|
MonitorLocker ml(threads_lock());
|
|
intptr_t count = 0;
|
|
Thread* current = active_list_;
|
|
while (current != NULL) {
|
|
if (current->isolate() == isolate_of_interest) {
|
|
count += current->CountZoneHandles();
|
|
}
|
|
current = current->next_;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
intptr_t ThreadRegistry::CountScopedHandles(
|
|
Isolate* isolate_of_interest) const {
|
|
MonitorLocker ml(threads_lock());
|
|
intptr_t count = 0;
|
|
Thread* current = active_list_;
|
|
while (current != NULL) {
|
|
if (current->isolate() == isolate_of_interest) {
|
|
count += current->CountScopedHandles();
|
|
}
|
|
current = current->next_;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
void ThreadRegistry::AddToActiveListLocked(Thread* thread) {
|
|
ASSERT(thread != NULL);
|
|
ASSERT(threads_lock()->IsOwnedByCurrentThread());
|
|
thread->next_ = active_list_;
|
|
active_list_ = thread;
|
|
}
|
|
|
|
void ThreadRegistry::RemoveFromActiveListLocked(Thread* thread) {
|
|
ASSERT(thread != NULL);
|
|
ASSERT(threads_lock()->IsOwnedByCurrentThread());
|
|
Thread* prev = NULL;
|
|
Thread* current = active_list_;
|
|
while (current != NULL) {
|
|
if (current == thread) {
|
|
if (prev == NULL) {
|
|
active_list_ = current->next_;
|
|
} else {
|
|
prev->next_ = current->next_;
|
|
}
|
|
break;
|
|
}
|
|
prev = current;
|
|
current = current->next_;
|
|
}
|
|
}
|
|
|
|
Thread* ThreadRegistry::GetFromFreelistLocked(bool is_vm_isolate) {
|
|
ASSERT(threads_lock()->IsOwnedByCurrentThread());
|
|
Thread* thread = NULL;
|
|
// Get thread structure from free list or create a new one.
|
|
if (free_list_ == NULL) {
|
|
thread = new Thread(is_vm_isolate);
|
|
} else {
|
|
thread = free_list_;
|
|
free_list_ = thread->next_;
|
|
}
|
|
return thread;
|
|
}
|
|
|
|
void ThreadRegistry::ReturnToFreelistLocked(Thread* thread) {
|
|
ASSERT(thread != NULL);
|
|
ASSERT(thread->os_thread() == NULL);
|
|
ASSERT(thread->isolate_ == NULL);
|
|
ASSERT(thread->heap_ == NULL);
|
|
ASSERT(threads_lock()->IsOwnedByCurrentThread());
|
|
// Add thread to the free list.
|
|
thread->next_ = free_list_;
|
|
free_list_ = thread;
|
|
}
|
|
|
|
} // namespace dart
|