Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 1 | // Copyright 2008 the V8 project authors. All rights reserved. |
| 2 | // Redistribution and use in source and binary forms, with or without |
| 3 | // modification, are permitted provided that the following conditions are |
| 4 | // met: |
| 5 | // |
| 6 | // * Redistributions of source code must retain the above copyright |
| 7 | // notice, this list of conditions and the following disclaimer. |
| 8 | // * Redistributions in binary form must reproduce the above |
| 9 | // copyright notice, this list of conditions and the following |
| 10 | // disclaimer in the documentation and/or other materials provided |
| 11 | // with the distribution. |
| 12 | // * Neither the name of Google Inc. nor the names of its |
| 13 | // contributors may be used to endorse or promote products derived |
| 14 | // from this software without specific prior written permission. |
| 15 | // |
| 16 | // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| 17 | // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| 18 | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| 19 | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| 20 | // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 21 | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| 22 | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 23 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 24 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 25 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| 26 | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 27 | |
| 28 | #include "v8.h" |
| 29 | |
| 30 | #include "api.h" |
| 31 | #include "bootstrapper.h" |
| 32 | #include "debug.h" |
| 33 | #include "execution.h" |
| 34 | #include "v8threads.h" |
| 35 | #include "regexp-stack.h" |
| 36 | |
| 37 | namespace v8 { |
| 38 | |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 39 | |
| 40 | // Track whether this V8 instance has ever called v8::Locker. This allows the |
| 41 | // API code to verify that the lock is always held when V8 is being entered. |
| 42 | bool Locker::active_ = false; |
| 43 | |
| 44 | |
| 45 | // Constructor for the Locker object. Once the Locker is constructed the |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 46 | // current thread will be guaranteed to have the lock for a given isolate. |
| 47 | Locker::Locker(v8::Isolate* isolate) |
| 48 | : has_lock_(false), |
Ben Murdoch | 3fb3ca8 | 2011-12-02 17:19:32 +0000 | [diff] [blame] | 49 | top_level_(true), |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 50 | isolate_(reinterpret_cast<i::Isolate*>(isolate)) { |
| 51 | if (isolate_ == NULL) { |
| 52 | isolate_ = i::Isolate::GetDefaultIsolateForLocking(); |
| 53 | } |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 54 | // Record that the Locker has been used at least once. |
| 55 | active_ = true; |
| 56 | // Get the big lock if necessary. |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 57 | if (!isolate_->thread_manager()->IsLockedByCurrentThread()) { |
| 58 | isolate_->thread_manager()->Lock(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 59 | has_lock_ = true; |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 60 | |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 61 | // Make sure that V8 is initialized. Archiving of threads interferes |
| 62 | // with deserialization by adding additional root pointers, so we must |
| 63 | // initialize here, before anyone can call ~Locker() or Unlocker(). |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 64 | if (!isolate_->IsInitialized()) { |
| 65 | isolate_->Enter(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 66 | V8::Initialize(); |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 67 | isolate_->Exit(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 68 | } |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 69 | |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 70 | // This may be a locker within an unlocker in which case we have to |
| 71 | // get the saved state for this thread and restore it. |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 72 | if (isolate_->thread_manager()->RestoreThread()) { |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 73 | top_level_ = false; |
| 74 | } else { |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 75 | internal::ExecutionAccess access(isolate_); |
| 76 | isolate_->stack_guard()->ClearThread(access); |
| 77 | isolate_->stack_guard()->InitThread(access); |
| 78 | } |
| 79 | if (isolate_->IsDefaultIsolate()) { |
| 80 | // This only enters if not yet entered. |
| 81 | internal::Isolate::EnterDefaultIsolate(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 82 | } |
| 83 | } |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 84 | ASSERT(isolate_->thread_manager()->IsLockedByCurrentThread()); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 85 | } |
| 86 | |
| 87 | |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 88 | bool Locker::IsLocked(v8::Isolate* isolate) { |
| 89 | i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate); |
| 90 | if (internal_isolate == NULL) { |
| 91 | internal_isolate = i::Isolate::GetDefaultIsolateForLocking(); |
| 92 | } |
| 93 | return internal_isolate->thread_manager()->IsLockedByCurrentThread(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 94 | } |
| 95 | |
| 96 | |
Ben Murdoch | 69a99ed | 2011-11-30 16:03:39 +0000 | [diff] [blame^] | 97 | bool Locker::IsActive() { |
| 98 | return active_; |
| 99 | } |
| 100 | |
| 101 | |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 102 | Locker::~Locker() { |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 103 | ASSERT(isolate_->thread_manager()->IsLockedByCurrentThread()); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 104 | if (has_lock_) { |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 105 | if (isolate_->IsDefaultIsolate()) { |
| 106 | isolate_->Exit(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 107 | } |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 108 | if (top_level_) { |
| 109 | isolate_->thread_manager()->FreeThreadResources(); |
| 110 | } else { |
| 111 | isolate_->thread_manager()->ArchiveThread(); |
| 112 | } |
| 113 | isolate_->thread_manager()->Unlock(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 114 | } |
| 115 | } |
| 116 | |
| 117 | |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 118 | Unlocker::Unlocker(v8::Isolate* isolate) |
| 119 | : isolate_(reinterpret_cast<i::Isolate*>(isolate)) { |
| 120 | if (isolate_ == NULL) { |
| 121 | isolate_ = i::Isolate::GetDefaultIsolateForLocking(); |
| 122 | } |
| 123 | ASSERT(isolate_->thread_manager()->IsLockedByCurrentThread()); |
| 124 | if (isolate_->IsDefaultIsolate()) { |
| 125 | isolate_->Exit(); |
| 126 | } |
| 127 | isolate_->thread_manager()->ArchiveThread(); |
| 128 | isolate_->thread_manager()->Unlock(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 129 | } |
| 130 | |
| 131 | |
| 132 | Unlocker::~Unlocker() { |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 133 | ASSERT(!isolate_->thread_manager()->IsLockedByCurrentThread()); |
| 134 | isolate_->thread_manager()->Lock(); |
| 135 | isolate_->thread_manager()->RestoreThread(); |
| 136 | if (isolate_->IsDefaultIsolate()) { |
| 137 | isolate_->Enter(); |
| 138 | } |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 139 | } |
| 140 | |
| 141 | |
| 142 | void Locker::StartPreemption(int every_n_ms) { |
| 143 | v8::internal::ContextSwitcher::StartPreemption(every_n_ms); |
| 144 | } |
| 145 | |
| 146 | |
| 147 | void Locker::StopPreemption() { |
| 148 | v8::internal::ContextSwitcher::StopPreemption(); |
| 149 | } |
| 150 | |
| 151 | |
| 152 | namespace internal { |
| 153 | |
| 154 | |
| 155 | bool ThreadManager::RestoreThread() { |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 156 | ASSERT(IsLockedByCurrentThread()); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 157 | // First check whether the current thread has been 'lazily archived', ie |
| 158 | // not archived at all. If that is the case we put the state storage we |
| 159 | // 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] | 160 | if (lazily_archived_thread_.Equals(ThreadId::Current())) { |
| 161 | lazily_archived_thread_ = ThreadId::Invalid(); |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 162 | Isolate::PerIsolateThreadData* per_thread = |
| 163 | isolate_->FindPerThreadDataForThisThread(); |
| 164 | ASSERT(per_thread != NULL); |
| 165 | ASSERT(per_thread->thread_state() == lazily_archived_thread_state_); |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 166 | lazily_archived_thread_state_->set_id(ThreadId::Invalid()); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 167 | lazily_archived_thread_state_->LinkInto(ThreadState::FREE_LIST); |
| 168 | lazily_archived_thread_state_ = NULL; |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 169 | per_thread->set_thread_state(NULL); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 170 | return true; |
| 171 | } |
| 172 | |
| 173 | // Make sure that the preemption thread cannot modify the thread state while |
| 174 | // it is being archived or restored. |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 175 | ExecutionAccess access(isolate_); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 176 | |
| 177 | // If there is another thread that was lazily archived then we have to really |
| 178 | // archive it now. |
| 179 | if (lazily_archived_thread_.IsValid()) { |
| 180 | EagerlyArchiveThread(); |
| 181 | } |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 182 | Isolate::PerIsolateThreadData* per_thread = |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 183 | isolate_->FindPerThreadDataForThisThread(); |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 184 | if (per_thread == NULL || per_thread->thread_state() == NULL) { |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 185 | // This is a new thread. |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 186 | isolate_->stack_guard()->InitThread(access); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 187 | return false; |
| 188 | } |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 189 | ThreadState* state = per_thread->thread_state(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 190 | char* from = state->data(); |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 191 | from = isolate_->handle_scope_implementer()->RestoreThread(from); |
| 192 | from = isolate_->RestoreThread(from); |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 193 | from = Relocatable::RestoreState(isolate_, from); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 194 | #ifdef ENABLE_DEBUGGER_SUPPORT |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 195 | from = isolate_->debug()->RestoreDebug(from); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 196 | #endif |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 197 | from = isolate_->stack_guard()->RestoreStackGuard(from); |
| 198 | from = isolate_->regexp_stack()->RestoreStack(from); |
| 199 | from = isolate_->bootstrapper()->RestoreState(from); |
| 200 | per_thread->set_thread_state(NULL); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 201 | if (state->terminate_on_restore()) { |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 202 | isolate_->stack_guard()->TerminateExecution(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 203 | state->set_terminate_on_restore(false); |
| 204 | } |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 205 | state->set_id(ThreadId::Invalid()); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 206 | state->Unlink(); |
| 207 | state->LinkInto(ThreadState::FREE_LIST); |
| 208 | return true; |
| 209 | } |
| 210 | |
| 211 | |
| 212 | void ThreadManager::Lock() { |
| 213 | mutex_->Lock(); |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 214 | mutex_owner_ = ThreadId::Current(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 215 | ASSERT(IsLockedByCurrentThread()); |
| 216 | } |
| 217 | |
| 218 | |
| 219 | void ThreadManager::Unlock() { |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 220 | mutex_owner_ = ThreadId::Invalid(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 221 | mutex_->Unlock(); |
| 222 | } |
| 223 | |
| 224 | |
| 225 | static int ArchiveSpacePerThread() { |
| 226 | return HandleScopeImplementer::ArchiveSpacePerThread() + |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 227 | Isolate::ArchiveSpacePerThread() + |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 228 | #ifdef ENABLE_DEBUGGER_SUPPORT |
| 229 | Debug::ArchiveSpacePerThread() + |
| 230 | #endif |
| 231 | StackGuard::ArchiveSpacePerThread() + |
| 232 | RegExpStack::ArchiveSpacePerThread() + |
| 233 | Bootstrapper::ArchiveSpacePerThread() + |
| 234 | Relocatable::ArchiveSpacePerThread(); |
| 235 | } |
| 236 | |
| 237 | |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 238 | ThreadState::ThreadState(ThreadManager* thread_manager) |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 239 | : id_(ThreadId::Invalid()), |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 240 | terminate_on_restore_(false), |
| 241 | next_(this), |
| 242 | previous_(this), |
| 243 | thread_manager_(thread_manager) { |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 244 | } |
| 245 | |
| 246 | |
| 247 | void ThreadState::AllocateSpace() { |
| 248 | data_ = NewArray<char>(ArchiveSpacePerThread()); |
| 249 | } |
| 250 | |
| 251 | |
| 252 | void ThreadState::Unlink() { |
| 253 | next_->previous_ = previous_; |
| 254 | previous_->next_ = next_; |
| 255 | } |
| 256 | |
| 257 | |
| 258 | void ThreadState::LinkInto(List list) { |
| 259 | ThreadState* flying_anchor = |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 260 | list == FREE_LIST ? thread_manager_->free_anchor_ |
| 261 | : thread_manager_->in_use_anchor_; |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 262 | next_ = flying_anchor->next_; |
| 263 | previous_ = flying_anchor; |
| 264 | flying_anchor->next_ = this; |
| 265 | next_->previous_ = this; |
| 266 | } |
| 267 | |
| 268 | |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 269 | ThreadState* ThreadManager::GetFreeThreadState() { |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 270 | ThreadState* gotten = free_anchor_->next_; |
| 271 | if (gotten == free_anchor_) { |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 272 | ThreadState* new_thread_state = new ThreadState(this); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 273 | new_thread_state->AllocateSpace(); |
| 274 | return new_thread_state; |
| 275 | } |
| 276 | return gotten; |
| 277 | } |
| 278 | |
| 279 | |
| 280 | // Gets the first in the list of archived threads. |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 281 | ThreadState* ThreadManager::FirstThreadStateInUse() { |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 282 | return in_use_anchor_->Next(); |
| 283 | } |
| 284 | |
| 285 | |
| 286 | ThreadState* ThreadState::Next() { |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 287 | if (next_ == thread_manager_->in_use_anchor_) return NULL; |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 288 | return next_; |
| 289 | } |
| 290 | |
| 291 | |
| 292 | // Thread ids must start with 1, because in TLS having thread id 0 can't |
| 293 | // be distinguished from not having a thread id at all (since NULL is |
| 294 | // defined as 0.) |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 295 | ThreadManager::ThreadManager() |
| 296 | : mutex_(OS::CreateMutex()), |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 297 | mutex_owner_(ThreadId::Invalid()), |
| 298 | lazily_archived_thread_(ThreadId::Invalid()), |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 299 | lazily_archived_thread_state_(NULL), |
| 300 | free_anchor_(NULL), |
| 301 | in_use_anchor_(NULL) { |
| 302 | free_anchor_ = new ThreadState(this); |
| 303 | in_use_anchor_ = new ThreadState(this); |
| 304 | } |
| 305 | |
| 306 | |
| 307 | ThreadManager::~ThreadManager() { |
Ben Murdoch | 69a99ed | 2011-11-30 16:03:39 +0000 | [diff] [blame^] | 308 | delete mutex_; |
| 309 | delete free_anchor_; |
| 310 | delete in_use_anchor_; |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 311 | } |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 312 | |
| 313 | |
| 314 | void ThreadManager::ArchiveThread() { |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 315 | ASSERT(lazily_archived_thread_.Equals(ThreadId::Invalid())); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 316 | ASSERT(!IsArchived()); |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 317 | ASSERT(IsLockedByCurrentThread()); |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 318 | ThreadState* state = GetFreeThreadState(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 319 | state->Unlink(); |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 320 | Isolate::PerIsolateThreadData* per_thread = |
| 321 | isolate_->FindOrAllocatePerThreadDataForThisThread(); |
| 322 | per_thread->set_thread_state(state); |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 323 | lazily_archived_thread_ = ThreadId::Current(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 324 | lazily_archived_thread_state_ = state; |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 325 | ASSERT(state->id().Equals(ThreadId::Invalid())); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 326 | state->set_id(CurrentId()); |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 327 | ASSERT(!state->id().Equals(ThreadId::Invalid())); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 328 | } |
| 329 | |
| 330 | |
| 331 | void ThreadManager::EagerlyArchiveThread() { |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 332 | ASSERT(IsLockedByCurrentThread()); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 333 | ThreadState* state = lazily_archived_thread_state_; |
| 334 | state->LinkInto(ThreadState::IN_USE_LIST); |
| 335 | char* to = state->data(); |
| 336 | // Ensure that data containing GC roots are archived first, and handle them |
| 337 | // in ThreadManager::Iterate(ObjectVisitor*). |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 338 | to = isolate_->handle_scope_implementer()->ArchiveThread(to); |
| 339 | to = isolate_->ArchiveThread(to); |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 340 | to = Relocatable::ArchiveState(isolate_, to); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 341 | #ifdef ENABLE_DEBUGGER_SUPPORT |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 342 | to = isolate_->debug()->ArchiveDebug(to); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 343 | #endif |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 344 | to = isolate_->stack_guard()->ArchiveStackGuard(to); |
| 345 | to = isolate_->regexp_stack()->ArchiveStack(to); |
| 346 | to = isolate_->bootstrapper()->ArchiveState(to); |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 347 | lazily_archived_thread_ = ThreadId::Invalid(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 348 | lazily_archived_thread_state_ = NULL; |
| 349 | } |
| 350 | |
| 351 | |
| 352 | void ThreadManager::FreeThreadResources() { |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 353 | isolate_->handle_scope_implementer()->FreeThreadResources(); |
| 354 | isolate_->FreeThreadResources(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 355 | #ifdef ENABLE_DEBUGGER_SUPPORT |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 356 | isolate_->debug()->FreeThreadResources(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 357 | #endif |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 358 | isolate_->stack_guard()->FreeThreadResources(); |
| 359 | isolate_->regexp_stack()->FreeThreadResources(); |
| 360 | isolate_->bootstrapper()->FreeThreadResources(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 361 | } |
| 362 | |
| 363 | |
| 364 | bool ThreadManager::IsArchived() { |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 365 | Isolate::PerIsolateThreadData* data = |
| 366 | isolate_->FindPerThreadDataForThisThread(); |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 367 | return data != NULL && data->thread_state() != NULL; |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 368 | } |
| 369 | |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 370 | void ThreadManager::Iterate(ObjectVisitor* v) { |
| 371 | // Expecting no threads during serialization/deserialization |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 372 | for (ThreadState* state = FirstThreadStateInUse(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 373 | state != NULL; |
| 374 | state = state->Next()) { |
| 375 | char* data = state->data(); |
| 376 | data = HandleScopeImplementer::Iterate(v, data); |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 377 | data = isolate_->Iterate(v, data); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 378 | data = Relocatable::Iterate(v, data); |
| 379 | } |
| 380 | } |
| 381 | |
| 382 | |
Ben Murdoch | 7f4d5bd | 2010-06-15 11:15:29 +0100 | [diff] [blame] | 383 | void ThreadManager::IterateArchivedThreads(ThreadVisitor* v) { |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 384 | for (ThreadState* state = FirstThreadStateInUse(); |
Steve Block | 6ded16b | 2010-05-10 14:33:55 +0100 | [diff] [blame] | 385 | state != NULL; |
| 386 | state = state->Next()) { |
| 387 | char* data = state->data(); |
| 388 | data += HandleScopeImplementer::ArchiveSpacePerThread(); |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 389 | isolate_->IterateThread(v, data); |
Steve Block | 6ded16b | 2010-05-10 14:33:55 +0100 | [diff] [blame] | 390 | } |
| 391 | } |
| 392 | |
| 393 | |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 394 | ThreadId ThreadManager::CurrentId() { |
| 395 | return ThreadId::Current(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 396 | } |
| 397 | |
| 398 | |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 399 | void ThreadManager::TerminateExecution(ThreadId thread_id) { |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 400 | for (ThreadState* state = FirstThreadStateInUse(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 401 | state != NULL; |
| 402 | state = state->Next()) { |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 403 | if (thread_id.Equals(state->id())) { |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 404 | state->set_terminate_on_restore(true); |
| 405 | } |
| 406 | } |
| 407 | } |
| 408 | |
| 409 | |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 410 | ContextSwitcher::ContextSwitcher(Isolate* isolate, int every_n_ms) |
Ben Murdoch | 3fb3ca8 | 2011-12-02 17:19:32 +0000 | [diff] [blame] | 411 | : Thread("v8:CtxtSwitcher"), |
Steve Block | 9fac840 | 2011-05-12 15:51:54 +0100 | [diff] [blame] | 412 | keep_going_(true), |
Ben Murdoch | 3fb3ca8 | 2011-12-02 17:19:32 +0000 | [diff] [blame] | 413 | sleep_ms_(every_n_ms), |
| 414 | isolate_(isolate) { |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 415 | } |
| 416 | |
| 417 | |
| 418 | // Set the scheduling interval of V8 threads. This function starts the |
| 419 | // ContextSwitcher thread if needed. |
| 420 | void ContextSwitcher::StartPreemption(int every_n_ms) { |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 421 | Isolate* isolate = Isolate::Current(); |
Ben Murdoch | 3fb3ca8 | 2011-12-02 17:19:32 +0000 | [diff] [blame] | 422 | ASSERT(Locker::IsLocked(reinterpret_cast<v8::Isolate*>(isolate))); |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 423 | if (isolate->context_switcher() == NULL) { |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 424 | // If the ContextSwitcher thread is not running at the moment start it now. |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 425 | isolate->set_context_switcher(new ContextSwitcher(isolate, every_n_ms)); |
| 426 | isolate->context_switcher()->Start(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 427 | } else { |
| 428 | // ContextSwitcher thread is already running, so we just change the |
| 429 | // scheduling interval. |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 430 | isolate->context_switcher()->sleep_ms_ = every_n_ms; |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 431 | } |
| 432 | } |
| 433 | |
| 434 | |
| 435 | // Disable preemption of V8 threads. If multiple threads want to use V8 they |
| 436 | // must cooperatively schedule amongst them from this point on. |
| 437 | void ContextSwitcher::StopPreemption() { |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 438 | Isolate* isolate = Isolate::Current(); |
Ben Murdoch | 3fb3ca8 | 2011-12-02 17:19:32 +0000 | [diff] [blame] | 439 | ASSERT(Locker::IsLocked(reinterpret_cast<v8::Isolate*>(isolate))); |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 440 | if (isolate->context_switcher() != NULL) { |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 441 | // The ContextSwitcher thread is running. We need to stop it and release |
| 442 | // its resources. |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 443 | isolate->context_switcher()->keep_going_ = false; |
| 444 | // Wait for the ContextSwitcher thread to exit. |
| 445 | isolate->context_switcher()->Join(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 446 | // Thread has exited, now we can delete it. |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 447 | delete(isolate->context_switcher()); |
| 448 | isolate->set_context_switcher(NULL); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 449 | } |
| 450 | } |
| 451 | |
| 452 | |
| 453 | // Main loop of the ContextSwitcher thread: Preempt the currently running V8 |
| 454 | // thread at regular intervals. |
| 455 | void ContextSwitcher::Run() { |
| 456 | while (keep_going_) { |
| 457 | OS::Sleep(sleep_ms_); |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 458 | isolate()->stack_guard()->Preempt(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 459 | } |
| 460 | } |
| 461 | |
| 462 | |
| 463 | // Acknowledge the preemption by the receiving thread. |
| 464 | void ContextSwitcher::PreemptionReceived() { |
| 465 | ASSERT(Locker::IsLocked()); |
| 466 | // There is currently no accounting being done for this. But could be in the |
| 467 | // future, which is why we leave this in. |
| 468 | } |
| 469 | |
| 470 | |
| 471 | } // namespace internal |
| 472 | } // namespace v8 |