Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 1 | // Copyright 2012 the V8 project authors. All rights reserved. |
| 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 4 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 5 | #include "src/v8.h" |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 6 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 7 | #include "src/api.h" |
| 8 | #include "src/bootstrapper.h" |
| 9 | #include "src/debug.h" |
| 10 | #include "src/execution.h" |
| 11 | #include "src/regexp-stack.h" |
| 12 | #include "src/v8threads.h" |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 13 | |
| 14 | namespace v8 { |
| 15 | |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 16 | |
| 17 | // Track whether this V8 instance has ever called v8::Locker. This allows the |
| 18 | // API code to verify that the lock is always held when V8 is being entered. |
| 19 | bool Locker::active_ = false; |
| 20 | |
| 21 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 22 | // Once the Locker is initialized, the current thread will be guaranteed to have |
| 23 | // the lock for a given isolate. |
| 24 | void Locker::Initialize(v8::Isolate* isolate) { |
| 25 | DCHECK(isolate != NULL); |
| 26 | has_lock_= false; |
| 27 | top_level_ = true; |
| 28 | isolate_ = reinterpret_cast<i::Isolate*>(isolate); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 29 | // Record that the Locker has been used at least once. |
| 30 | active_ = true; |
| 31 | // Get the big lock if necessary. |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 32 | if (!isolate_->thread_manager()->IsLockedByCurrentThread()) { |
| 33 | isolate_->thread_manager()->Lock(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 34 | has_lock_ = true; |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 35 | |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 36 | // Make sure that V8 is initialized. Archiving of threads interferes |
| 37 | // with deserialization by adding additional root pointers, so we must |
| 38 | // initialize here, before anyone can call ~Locker() or Unlocker(). |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 39 | if (!isolate_->IsInitialized()) { |
| 40 | isolate_->Enter(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 41 | V8::Initialize(); |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 42 | isolate_->Exit(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 43 | } |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 44 | |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 45 | // This may be a locker within an unlocker in which case we have to |
| 46 | // get the saved state for this thread and restore it. |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 47 | if (isolate_->thread_manager()->RestoreThread()) { |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 48 | top_level_ = false; |
| 49 | } else { |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 50 | internal::ExecutionAccess access(isolate_); |
| 51 | isolate_->stack_guard()->ClearThread(access); |
| 52 | isolate_->stack_guard()->InitThread(access); |
| 53 | } |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 54 | } |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 55 | DCHECK(isolate_->thread_manager()->IsLockedByCurrentThread()); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 56 | } |
| 57 | |
| 58 | |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 59 | bool Locker::IsLocked(v8::Isolate* isolate) { |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 60 | DCHECK(isolate != NULL); |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 61 | i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate); |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 62 | return internal_isolate->thread_manager()->IsLockedByCurrentThread(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 63 | } |
| 64 | |
| 65 | |
Ben Murdoch | 69a99ed | 2011-11-30 16:03:39 +0000 | [diff] [blame] | 66 | bool Locker::IsActive() { |
| 67 | return active_; |
| 68 | } |
| 69 | |
| 70 | |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 71 | Locker::~Locker() { |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 72 | DCHECK(isolate_->thread_manager()->IsLockedByCurrentThread()); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 73 | if (has_lock_) { |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 74 | if (top_level_) { |
| 75 | isolate_->thread_manager()->FreeThreadResources(); |
| 76 | } else { |
| 77 | isolate_->thread_manager()->ArchiveThread(); |
| 78 | } |
| 79 | isolate_->thread_manager()->Unlock(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 80 | } |
| 81 | } |
| 82 | |
| 83 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 84 | void Unlocker::Initialize(v8::Isolate* isolate) { |
| 85 | DCHECK(isolate != NULL); |
| 86 | isolate_ = reinterpret_cast<i::Isolate*>(isolate); |
| 87 | DCHECK(isolate_->thread_manager()->IsLockedByCurrentThread()); |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 88 | isolate_->thread_manager()->ArchiveThread(); |
| 89 | isolate_->thread_manager()->Unlock(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 90 | } |
| 91 | |
| 92 | |
| 93 | Unlocker::~Unlocker() { |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 94 | DCHECK(!isolate_->thread_manager()->IsLockedByCurrentThread()); |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 95 | isolate_->thread_manager()->Lock(); |
| 96 | isolate_->thread_manager()->RestoreThread(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 97 | } |
| 98 | |
| 99 | |
| 100 | namespace internal { |
| 101 | |
| 102 | |
| 103 | bool ThreadManager::RestoreThread() { |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 104 | DCHECK(IsLockedByCurrentThread()); |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 105 | // First check whether the current thread has been 'lazily archived', i.e. |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 106 | // not archived at all. If that is the case we put the state storage we |
| 107 | // had prepared back in the free list, since we didn't need it after all. |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 108 | if (lazily_archived_thread_.Equals(ThreadId::Current())) { |
| 109 | lazily_archived_thread_ = ThreadId::Invalid(); |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 110 | Isolate::PerIsolateThreadData* per_thread = |
| 111 | isolate_->FindPerThreadDataForThisThread(); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 112 | DCHECK(per_thread != NULL); |
| 113 | DCHECK(per_thread->thread_state() == lazily_archived_thread_state_); |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 114 | lazily_archived_thread_state_->set_id(ThreadId::Invalid()); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 115 | lazily_archived_thread_state_->LinkInto(ThreadState::FREE_LIST); |
| 116 | lazily_archived_thread_state_ = NULL; |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 117 | per_thread->set_thread_state(NULL); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 118 | return true; |
| 119 | } |
| 120 | |
| 121 | // Make sure that the preemption thread cannot modify the thread state while |
| 122 | // it is being archived or restored. |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 123 | ExecutionAccess access(isolate_); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 124 | |
| 125 | // If there is another thread that was lazily archived then we have to really |
| 126 | // archive it now. |
| 127 | if (lazily_archived_thread_.IsValid()) { |
| 128 | EagerlyArchiveThread(); |
| 129 | } |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 130 | Isolate::PerIsolateThreadData* per_thread = |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 131 | isolate_->FindPerThreadDataForThisThread(); |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 132 | if (per_thread == NULL || per_thread->thread_state() == NULL) { |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 133 | // This is a new thread. |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 134 | isolate_->stack_guard()->InitThread(access); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 135 | return false; |
| 136 | } |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 137 | ThreadState* state = per_thread->thread_state(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 138 | char* from = state->data(); |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 139 | from = isolate_->handle_scope_implementer()->RestoreThread(from); |
| 140 | from = isolate_->RestoreThread(from); |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 141 | from = Relocatable::RestoreState(isolate_, from); |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 142 | from = isolate_->debug()->RestoreDebug(from); |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 143 | from = isolate_->stack_guard()->RestoreStackGuard(from); |
| 144 | from = isolate_->regexp_stack()->RestoreStack(from); |
| 145 | from = isolate_->bootstrapper()->RestoreState(from); |
| 146 | per_thread->set_thread_state(NULL); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 147 | if (state->terminate_on_restore()) { |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 148 | isolate_->stack_guard()->RequestTerminateExecution(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 149 | state->set_terminate_on_restore(false); |
| 150 | } |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 151 | state->set_id(ThreadId::Invalid()); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 152 | state->Unlink(); |
| 153 | state->LinkInto(ThreadState::FREE_LIST); |
| 154 | return true; |
| 155 | } |
| 156 | |
| 157 | |
| 158 | void ThreadManager::Lock() { |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 159 | mutex_.Lock(); |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 160 | mutex_owner_ = ThreadId::Current(); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 161 | DCHECK(IsLockedByCurrentThread()); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 162 | } |
| 163 | |
| 164 | |
| 165 | void ThreadManager::Unlock() { |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 166 | mutex_owner_ = ThreadId::Invalid(); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 167 | mutex_.Unlock(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 168 | } |
| 169 | |
| 170 | |
| 171 | static int ArchiveSpacePerThread() { |
| 172 | return HandleScopeImplementer::ArchiveSpacePerThread() + |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 173 | Isolate::ArchiveSpacePerThread() + |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 174 | Debug::ArchiveSpacePerThread() + |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 175 | StackGuard::ArchiveSpacePerThread() + |
| 176 | RegExpStack::ArchiveSpacePerThread() + |
| 177 | Bootstrapper::ArchiveSpacePerThread() + |
| 178 | Relocatable::ArchiveSpacePerThread(); |
| 179 | } |
| 180 | |
| 181 | |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 182 | ThreadState::ThreadState(ThreadManager* thread_manager) |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 183 | : id_(ThreadId::Invalid()), |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 184 | terminate_on_restore_(false), |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 185 | data_(NULL), |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 186 | next_(this), |
| 187 | previous_(this), |
| 188 | thread_manager_(thread_manager) { |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 189 | } |
| 190 | |
| 191 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 192 | ThreadState::~ThreadState() { |
| 193 | DeleteArray<char>(data_); |
| 194 | } |
| 195 | |
| 196 | |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 197 | void ThreadState::AllocateSpace() { |
| 198 | data_ = NewArray<char>(ArchiveSpacePerThread()); |
| 199 | } |
| 200 | |
| 201 | |
| 202 | void ThreadState::Unlink() { |
| 203 | next_->previous_ = previous_; |
| 204 | previous_->next_ = next_; |
| 205 | } |
| 206 | |
| 207 | |
| 208 | void ThreadState::LinkInto(List list) { |
| 209 | ThreadState* flying_anchor = |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 210 | list == FREE_LIST ? thread_manager_->free_anchor_ |
| 211 | : thread_manager_->in_use_anchor_; |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 212 | next_ = flying_anchor->next_; |
| 213 | previous_ = flying_anchor; |
| 214 | flying_anchor->next_ = this; |
| 215 | next_->previous_ = this; |
| 216 | } |
| 217 | |
| 218 | |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 219 | ThreadState* ThreadManager::GetFreeThreadState() { |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 220 | ThreadState* gotten = free_anchor_->next_; |
| 221 | if (gotten == free_anchor_) { |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 222 | ThreadState* new_thread_state = new ThreadState(this); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 223 | new_thread_state->AllocateSpace(); |
| 224 | return new_thread_state; |
| 225 | } |
| 226 | return gotten; |
| 227 | } |
| 228 | |
| 229 | |
| 230 | // Gets the first in the list of archived threads. |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 231 | ThreadState* ThreadManager::FirstThreadStateInUse() { |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 232 | return in_use_anchor_->Next(); |
| 233 | } |
| 234 | |
| 235 | |
| 236 | ThreadState* ThreadState::Next() { |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 237 | if (next_ == thread_manager_->in_use_anchor_) return NULL; |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 238 | return next_; |
| 239 | } |
| 240 | |
| 241 | |
| 242 | // Thread ids must start with 1, because in TLS having thread id 0 can't |
| 243 | // be distinguished from not having a thread id at all (since NULL is |
| 244 | // defined as 0.) |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 245 | ThreadManager::ThreadManager() |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 246 | : mutex_owner_(ThreadId::Invalid()), |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 247 | lazily_archived_thread_(ThreadId::Invalid()), |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 248 | lazily_archived_thread_state_(NULL), |
| 249 | free_anchor_(NULL), |
| 250 | in_use_anchor_(NULL) { |
| 251 | free_anchor_ = new ThreadState(this); |
| 252 | in_use_anchor_ = new ThreadState(this); |
| 253 | } |
| 254 | |
| 255 | |
| 256 | ThreadManager::~ThreadManager() { |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 257 | DeleteThreadStateList(free_anchor_); |
| 258 | DeleteThreadStateList(in_use_anchor_); |
| 259 | } |
| 260 | |
| 261 | |
| 262 | void ThreadManager::DeleteThreadStateList(ThreadState* anchor) { |
| 263 | // The list starts and ends with the anchor. |
| 264 | for (ThreadState* current = anchor->next_; current != anchor;) { |
| 265 | ThreadState* next = current->next_; |
| 266 | delete current; |
| 267 | current = next; |
| 268 | } |
| 269 | delete anchor; |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 270 | } |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 271 | |
| 272 | |
| 273 | void ThreadManager::ArchiveThread() { |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 274 | DCHECK(lazily_archived_thread_.Equals(ThreadId::Invalid())); |
| 275 | DCHECK(!IsArchived()); |
| 276 | DCHECK(IsLockedByCurrentThread()); |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 277 | ThreadState* state = GetFreeThreadState(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 278 | state->Unlink(); |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 279 | Isolate::PerIsolateThreadData* per_thread = |
| 280 | isolate_->FindOrAllocatePerThreadDataForThisThread(); |
| 281 | per_thread->set_thread_state(state); |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 282 | lazily_archived_thread_ = ThreadId::Current(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 283 | lazily_archived_thread_state_ = state; |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 284 | DCHECK(state->id().Equals(ThreadId::Invalid())); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 285 | state->set_id(CurrentId()); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 286 | DCHECK(!state->id().Equals(ThreadId::Invalid())); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 287 | } |
| 288 | |
| 289 | |
| 290 | void ThreadManager::EagerlyArchiveThread() { |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 291 | DCHECK(IsLockedByCurrentThread()); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 292 | ThreadState* state = lazily_archived_thread_state_; |
| 293 | state->LinkInto(ThreadState::IN_USE_LIST); |
| 294 | char* to = state->data(); |
| 295 | // Ensure that data containing GC roots are archived first, and handle them |
| 296 | // in ThreadManager::Iterate(ObjectVisitor*). |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 297 | to = isolate_->handle_scope_implementer()->ArchiveThread(to); |
| 298 | to = isolate_->ArchiveThread(to); |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 299 | to = Relocatable::ArchiveState(isolate_, to); |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 300 | to = isolate_->debug()->ArchiveDebug(to); |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 301 | to = isolate_->stack_guard()->ArchiveStackGuard(to); |
| 302 | to = isolate_->regexp_stack()->ArchiveStack(to); |
| 303 | to = isolate_->bootstrapper()->ArchiveState(to); |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 304 | lazily_archived_thread_ = ThreadId::Invalid(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 305 | lazily_archived_thread_state_ = NULL; |
| 306 | } |
| 307 | |
| 308 | |
| 309 | void ThreadManager::FreeThreadResources() { |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 310 | DCHECK(!isolate_->has_pending_exception()); |
| 311 | DCHECK(!isolate_->external_caught_exception()); |
| 312 | DCHECK(isolate_->try_catch_handler() == NULL); |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 313 | isolate_->handle_scope_implementer()->FreeThreadResources(); |
| 314 | isolate_->FreeThreadResources(); |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 315 | isolate_->debug()->FreeThreadResources(); |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 316 | isolate_->stack_guard()->FreeThreadResources(); |
| 317 | isolate_->regexp_stack()->FreeThreadResources(); |
| 318 | isolate_->bootstrapper()->FreeThreadResources(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 319 | } |
| 320 | |
| 321 | |
| 322 | bool ThreadManager::IsArchived() { |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 323 | Isolate::PerIsolateThreadData* data = |
| 324 | isolate_->FindPerThreadDataForThisThread(); |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 325 | return data != NULL && data->thread_state() != NULL; |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 326 | } |
| 327 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 328 | |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 329 | void ThreadManager::Iterate(ObjectVisitor* v) { |
| 330 | // Expecting no threads during serialization/deserialization |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 331 | for (ThreadState* state = FirstThreadStateInUse(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 332 | state != NULL; |
| 333 | state = state->Next()) { |
| 334 | char* data = state->data(); |
| 335 | data = HandleScopeImplementer::Iterate(v, data); |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 336 | data = isolate_->Iterate(v, data); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 337 | data = Relocatable::Iterate(v, data); |
| 338 | } |
| 339 | } |
| 340 | |
| 341 | |
Ben Murdoch | 7f4d5bd | 2010-06-15 11:15:29 +0100 | [diff] [blame] | 342 | void ThreadManager::IterateArchivedThreads(ThreadVisitor* v) { |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 343 | for (ThreadState* state = FirstThreadStateInUse(); |
Steve Block | 6ded16b | 2010-05-10 14:33:55 +0100 | [diff] [blame] | 344 | state != NULL; |
| 345 | state = state->Next()) { |
| 346 | char* data = state->data(); |
| 347 | data += HandleScopeImplementer::ArchiveSpacePerThread(); |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 348 | isolate_->IterateThread(v, data); |
Steve Block | 6ded16b | 2010-05-10 14:33:55 +0100 | [diff] [blame] | 349 | } |
| 350 | } |
| 351 | |
| 352 | |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 353 | ThreadId ThreadManager::CurrentId() { |
| 354 | return ThreadId::Current(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 355 | } |
| 356 | |
| 357 | |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 358 | void ThreadManager::TerminateExecution(ThreadId thread_id) { |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 359 | for (ThreadState* state = FirstThreadStateInUse(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 360 | state != NULL; |
| 361 | state = state->Next()) { |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 362 | if (thread_id.Equals(state->id())) { |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 363 | state->set_terminate_on_restore(true); |
| 364 | } |
| 365 | } |
| 366 | } |
| 367 | |
| 368 | |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 369 | } // namespace internal |
| 370 | } // namespace v8 |