2012-07-02 12:15:23 +00:00
|
|
|
// Copyright 2012 the V8 project authors. All rights reserved.
|
2014-04-29 06:42:26 +00:00
|
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
|
|
// found in the LICENSE file.
|
2008-07-03 15:10:15 +00:00
|
|
|
|
|
|
|
#ifndef V8_V8THREADS_H_
|
|
|
|
#define V8_V8THREADS_H_
|
|
|
|
|
2015-08-20 07:44:00 +00:00
|
|
|
#include "src/isolate.h"
|
|
|
|
|
2009-05-25 10:05:56 +00:00
|
|
|
namespace v8 {
|
|
|
|
namespace internal {
|
2008-07-03 15:10:15 +00:00
|
|
|
|
2017-04-25 13:32:18 +00:00
|
|
|
class RootVisitor;
|
|
|
|
class ThreadLocalTop;
|
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
|
|
|
};
|
|
|
|
|
2010-03-20 22:37:15 +00:00
|
|
|
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
|
|
|
|
2017-04-25 13:32:18 +00:00
|
|
|
void Iterate(RootVisitor* v);
|
2011-03-18 20:35:07 +00:00
|
|
|
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();
|
|
|
|
|
2014-06-30 13:25:46 +00:00
|
|
|
base::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
|
|
|
};
|
|
|
|
|
|
|
|
|
2015-09-30 13:46:56 +00:00
|
|
|
} // namespace internal
|
|
|
|
} // namespace v8
|
2008-07-03 15:10:15 +00:00
|
|
|
|
|
|
|
#endif // V8_V8THREADS_H_
|