V8 API Reference, 7.2.502.16 (for Deno 0.2.4)
v8threads.h
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.
4 
5 #ifndef V8_V8THREADS_H_
6 #define V8_V8THREADS_H_
7 
8 #include "src/isolate.h"
9 
10 namespace v8 {
11 namespace internal {
12 
13 class RootVisitor;
14 class ThreadLocalTop;
15 
16 class ThreadState {
17  public:
18  // Returns nullptr after the last one.
19  ThreadState* Next();
20 
21  enum List {FREE_LIST, IN_USE_LIST};
22 
23  void LinkInto(List list);
24  void Unlink();
25 
26  // Id of thread.
27  void set_id(ThreadId id) { id_ = id; }
28  ThreadId id() { return id_; }
29 
30  // Should the thread be terminated when it is restored?
31  bool terminate_on_restore() { return terminate_on_restore_; }
32  void set_terminate_on_restore(bool terminate_on_restore) {
33  terminate_on_restore_ = terminate_on_restore;
34  }
35 
36  // Get data area for archiving a thread.
37  char* data() { return data_; }
38 
39  private:
40  explicit ThreadState(ThreadManager* thread_manager);
41  ~ThreadState();
42 
43  void AllocateSpace();
44 
45  ThreadId id_;
46  bool terminate_on_restore_;
47  char* data_;
48  ThreadState* next_;
49  ThreadState* previous_;
50 
51  ThreadManager* thread_manager_;
52 
53  friend class ThreadManager;
54 };
55 
57  public:
58  // ThreadLocalTop may be only available during this call.
59  virtual void VisitThread(Isolate* isolate, ThreadLocalTop* top) = 0;
60 
61  protected:
62  virtual ~ThreadVisitor() = default;
63 };
64 
66  public:
67  void Lock();
68  void Unlock();
69 
70  void InitThread(const ExecutionAccess&);
71  void ArchiveThread();
72  bool RestoreThread();
73  void FreeThreadResources();
74  bool IsArchived();
75 
76  void Iterate(RootVisitor* v);
77  void IterateArchivedThreads(ThreadVisitor* v);
78  bool IsLockedByCurrentThread() {
79  return mutex_owner_.Equals(ThreadId::Current());
80  }
81 
82  ThreadId CurrentId();
83 
84  void TerminateExecution(ThreadId thread_id);
85 
86  // Iterate over in-use states.
87  ThreadState* FirstThreadStateInUse();
88  ThreadState* GetFreeThreadState();
89 
90  private:
91  explicit ThreadManager(Isolate* isolate);
92  ~ThreadManager();
93 
94  void DeleteThreadStateList(ThreadState* anchor);
95 
96  void EagerlyArchiveThread();
97 
98  base::Mutex mutex_;
99  ThreadId mutex_owner_;
100  ThreadId lazily_archived_thread_;
101  ThreadState* lazily_archived_thread_state_;
102 
103  // In the following two lists there is always at least one object on the list.
104  // The first object is a flying anchor that is only there to simplify linking
105  // and unlinking.
106  // Head of linked list of free states.
107  ThreadState* free_anchor_;
108  // Head of linked list of states in use.
109  ThreadState* in_use_anchor_;
110 
111  Isolate* isolate_;
112 
113  friend class Isolate;
114  friend class ThreadState;
115 };
116 
117 
118 } // namespace internal
119 } // namespace v8
120 
121 #endif // V8_V8THREADS_H_
Definition: libplatform.h:13