2012-07-02 12:15:23 +00:00
|
|
|
// Copyright 2012 the V8 project authors. All rights reserved.
|
2008-07-03 15:10:15 +00:00
|
|
|
// Redistribution and use in source and binary forms, with or without
|
|
|
|
// modification, are permitted provided that the following conditions are
|
|
|
|
// met:
|
|
|
|
//
|
|
|
|
// * Redistributions of source code must retain the above copyright
|
|
|
|
// notice, this list of conditions and the following disclaimer.
|
|
|
|
// * Redistributions in binary form must reproduce the above
|
|
|
|
// copyright notice, this list of conditions and the following
|
|
|
|
// disclaimer in the documentation and/or other materials provided
|
|
|
|
// with the distribution.
|
|
|
|
// * Neither the name of Google Inc. nor the names of its
|
|
|
|
// contributors may be used to endorse or promote products derived
|
|
|
|
// from this software without specific prior written permission.
|
|
|
|
//
|
|
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
|
|
|
#ifndef V8_V8THREADS_H_
|
|
|
|
#define V8_V8THREADS_H_
|
|
|
|
|
2009-05-25 10:05:56 +00:00
|
|
|
namespace v8 {
|
|
|
|
namespace internal {
|
2008-07-03 15:10:15 +00:00
|
|
|
|
|
|
|
|
|
|
|
class ThreadState {
|
|
|
|
public:
|
|
|
|
// Returns NULL after the last one.
|
|
|
|
ThreadState* Next();
|
|
|
|
|
|
|
|
enum List {FREE_LIST, IN_USE_LIST};
|
|
|
|
|
|
|
|
void LinkInto(List list);
|
|
|
|
void Unlink();
|
|
|
|
|
2009-03-17 11:40:47 +00:00
|
|
|
// Id of thread.
|
2011-04-11 23:46:22 +00:00
|
|
|
void set_id(ThreadId id) { id_ = id; }
|
|
|
|
ThreadId id() { return id_; }
|
2009-03-17 11:40:47 +00:00
|
|
|
|
2009-08-19 15:14:11 +00:00
|
|
|
// Should the thread be terminated when it is restored?
|
|
|
|
bool terminate_on_restore() { return terminate_on_restore_; }
|
|
|
|
void set_terminate_on_restore(bool terminate_on_restore) {
|
|
|
|
terminate_on_restore_ = terminate_on_restore;
|
|
|
|
}
|
|
|
|
|
2008-07-03 15:10:15 +00:00
|
|
|
// Get data area for archiving a thread.
|
|
|
|
char* data() { return data_; }
|
2011-09-08 19:57:14 +00:00
|
|
|
|
2008-07-03 15:10:15 +00:00
|
|
|
private:
|
2011-03-18 20:35:07 +00:00
|
|
|
explicit ThreadState(ThreadManager* thread_manager);
|
2012-07-02 12:15:23 +00:00
|
|
|
~ThreadState();
|
2008-07-03 15:10:15 +00:00
|
|
|
|
|
|
|
void AllocateSpace();
|
|
|
|
|
2011-04-11 23:46:22 +00:00
|
|
|
ThreadId id_;
|
2009-08-19 15:14:11 +00:00
|
|
|
bool terminate_on_restore_;
|
2008-07-03 15:10:15 +00:00
|
|
|
char* data_;
|
|
|
|
ThreadState* next_;
|
|
|
|
ThreadState* previous_;
|
2009-03-17 11:40:47 +00:00
|
|
|
|
2011-03-18 20:35:07 +00:00
|
|
|
ThreadManager* thread_manager_;
|
|
|
|
|
|
|
|
friend class ThreadManager;
|
2008-07-03 15:10:15 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2011-12-08 16:07:07 +00:00
|
|
|
// Defined in isolate.h.
|
2010-03-20 22:37:15 +00:00
|
|
|
class ThreadLocalTop;
|
|
|
|
|
|
|
|
|
|
|
|
class ThreadVisitor {
|
|
|
|
public:
|
|
|
|
// ThreadLocalTop may be only available during this call.
|
Simplify isolates access during stack iteration (WAS: Move SafeStackFrameIterator::active_count_...)
While trying to fix Mac and Windows versions for this change:
http://codereview.chromium.org/6771047/, I figured out, that we
already store an isolate in StackFrameIterator, so we can use it in
frame objects, instead of requiring it from caller.
I've changed iterators usage to the following scheme: whenever a
caller maintains an isolate pointer, it just passes it to stack
iterator, and no more worries about passing it to frame content
accessors. If a caller uses current isolate, it can omit passing it
to iterator, in this case, an iterator will use the current isolate,
too.
There was a special case with LiveEdit, which creates
detached copies of frame objects.
R=vitalyr@chromium.org
BUG=none
TEST=none
Review URL: http://codereview.chromium.org/6794019
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@7499 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2011-04-05 09:01:47 +00:00
|
|
|
virtual void VisitThread(Isolate* isolate, ThreadLocalTop* top) = 0;
|
2010-03-20 22:37:15 +00:00
|
|
|
|
|
|
|
protected:
|
|
|
|
virtual ~ThreadVisitor() {}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2011-03-18 20:35:07 +00:00
|
|
|
class ThreadManager {
|
2008-07-03 15:10:15 +00:00
|
|
|
public:
|
2011-03-18 20:35:07 +00:00
|
|
|
void Lock();
|
|
|
|
void Unlock();
|
2008-07-03 15:10:15 +00:00
|
|
|
|
2011-03-18 20:35:07 +00:00
|
|
|
void ArchiveThread();
|
|
|
|
bool RestoreThread();
|
|
|
|
void FreeThreadResources();
|
|
|
|
bool IsArchived();
|
2008-07-03 15:10:15 +00:00
|
|
|
|
2011-03-18 20:35:07 +00:00
|
|
|
void Iterate(ObjectVisitor* v);
|
|
|
|
void IterateArchivedThreads(ThreadVisitor* v);
|
2011-04-11 23:46:22 +00:00
|
|
|
bool IsLockedByCurrentThread() {
|
|
|
|
return mutex_owner_.Equals(ThreadId::Current());
|
|
|
|
}
|
2009-03-17 11:40:47 +00:00
|
|
|
|
2011-04-11 23:46:22 +00:00
|
|
|
ThreadId CurrentId();
|
2009-03-17 11:40:47 +00:00
|
|
|
|
2011-04-11 23:46:22 +00:00
|
|
|
void TerminateExecution(ThreadId thread_id);
|
2011-03-18 20:35:07 +00:00
|
|
|
|
|
|
|
// Iterate over in-use states.
|
|
|
|
ThreadState* FirstThreadStateInUse();
|
|
|
|
ThreadState* GetFreeThreadState();
|
2009-08-19 15:14:11 +00:00
|
|
|
|
2008-07-03 15:10:15 +00:00
|
|
|
private:
|
2011-03-18 20:35:07 +00:00
|
|
|
ThreadManager();
|
|
|
|
~ThreadManager();
|
2008-07-03 15:10:15 +00:00
|
|
|
|
2012-07-02 12:15:23 +00:00
|
|
|
void DeleteThreadStateList(ThreadState* anchor);
|
|
|
|
|
2011-03-18 20:35:07 +00:00
|
|
|
void EagerlyArchiveThread();
|
|
|
|
|
2013-08-29 09:58:30 +00:00
|
|
|
Mutex mutex_;
|
2011-04-11 23:46:22 +00:00
|
|
|
ThreadId mutex_owner_;
|
|
|
|
ThreadId lazily_archived_thread_;
|
2011-03-18 20:35:07 +00:00
|
|
|
ThreadState* lazily_archived_thread_state_;
|
|
|
|
|
|
|
|
// In the following two lists there is always at least one object on the list.
|
|
|
|
// The first object is a flying anchor that is only there to simplify linking
|
|
|
|
// and unlinking.
|
|
|
|
// Head of linked list of free states.
|
|
|
|
ThreadState* free_anchor_;
|
|
|
|
// Head of linked list of states in use.
|
|
|
|
ThreadState* in_use_anchor_;
|
|
|
|
|
|
|
|
Isolate* isolate_;
|
|
|
|
|
|
|
|
friend class Isolate;
|
|
|
|
friend class ThreadState;
|
2008-07-03 15:10:15 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
} } // namespace v8::internal
|
|
|
|
|
|
|
|
#endif // V8_V8THREADS_H_
|