blob: 7657fa805f6046586bacf67030a2896e81a452e4 [file] [log] [blame]
Elliott Hughes8daa0922011-09-11 13:46:25 -07001/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Brian Carlstromfc0e3212013-07-17 14:40:12 -070017#ifndef ART_RUNTIME_THREAD_LIST_H_
18#define ART_RUNTIME_THREAD_LIST_H_
Elliott Hughes8daa0922011-09-11 13:46:25 -070019
Hiroshi Yamauchi30493242016-11-03 13:06:52 -070020#include "barrier.h"
Mathieu Chartier70a596d2014-12-17 14:56:47 -080021#include "base/histogram.h"
Elliott Hughes76b61672012-12-12 17:47:30 -080022#include "base/mutex.h"
Mathieu Chartier3fceaf52017-01-22 13:33:40 -080023#include "base/time_utils.h"
Mathieu Chartier4f55e222015-09-04 13:26:21 -070024#include "base/value_object.h"
Ian Rogersd9c4fc92013-10-01 19:45:43 -070025#include "jni.h"
Alex Light46f93402017-06-29 11:59:50 -070026#include "suspend_reason.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080027
28#include <bitset>
29#include <list>
Hiroshi Yamauchia82769c2016-12-02 17:01:51 -080030#include <vector>
Elliott Hughes8daa0922011-09-11 13:46:25 -070031
32namespace art {
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -080033namespace gc {
Igor Murashkin2ffb7032017-11-08 13:35:21 -080034namespace collector {
35class GarbageCollector;
36} // namespace collector
37class GcPauseListener;
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -080038} // namespace gc
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080039class Closure;
Andreas Gampe513061a2017-06-01 09:17:34 -070040class RootVisitor;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080041class Thread;
Mathieu Chartier7664f5c2012-06-08 18:15:32 -070042class TimingLogger;
Andreas Gampe513061a2017-06-01 09:17:34 -070043enum VisitRootFlags : uint8_t;
Mathieu Chartier7664f5c2012-06-08 18:15:32 -070044
Elliott Hughes8daa0922011-09-11 13:46:25 -070045class ThreadList {
46 public:
Mathieu Chartier3fceaf52017-01-22 13:33:40 -080047 static constexpr uint32_t kMaxThreadId = 0xFFFF;
48 static constexpr uint32_t kInvalidThreadId = 0;
49 static constexpr uint32_t kMainThreadId = 1;
50 static constexpr uint64_t kDefaultThreadSuspendTimeout = MsToNs(kIsDebugBuild ? 50000 : 10000);
Elliott Hughes8daa0922011-09-11 13:46:25 -070051
Mathieu Chartier3fceaf52017-01-22 13:33:40 -080052 explicit ThreadList(uint64_t thread_suspend_timeout_ns);
Elliott Hughes8daa0922011-09-11 13:46:25 -070053 ~ThreadList();
54
Andreas Gampec4bed162017-05-01 13:46:24 -070055 void ShutDown();
56
Ian Rogers00f7d0e2012-07-19 15:28:27 -070057 void DumpForSigQuit(std::ostream& os)
Mathieu Chartier90443472015-07-16 20:32:27 -070058 REQUIRES(!Locks::thread_list_lock_, !Locks::mutator_lock_);
Ian Rogers7b078e82014-09-10 14:44:24 -070059 // For thread suspend timeout dumps.
Nicolas Geoffraya73280d2016-02-15 13:05:16 +000060 void Dump(std::ostream& os, bool dump_native_stack = true)
Mathieu Chartier90443472015-07-16 20:32:27 -070061 REQUIRES(!Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_);
Brian Carlstrom7934ac22013-07-26 10:54:15 -070062 pid_t GetLockOwner(); // For SignalCatcher.
Elliott Hughes8daa0922011-09-11 13:46:25 -070063
Elliott Hughes8d768a92011-09-14 16:35:25 -070064 // Thread suspension support.
Ian Rogers00f7d0e2012-07-19 15:28:27 -070065 void ResumeAll()
Mathieu Chartierb56200b2015-10-29 10:41:51 -070066 REQUIRES(!Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_)
67 UNLOCK_FUNCTION(Locks::mutator_lock_);
Alex Light88fd7202017-06-30 08:31:59 -070068 bool Resume(Thread* thread, SuspendReason reason = SuspendReason::kInternal)
69 REQUIRES(!Locks::thread_suspend_count_lock_) WARN_UNUSED;
Ian Rogers00f7d0e2012-07-19 15:28:27 -070070
71 // Suspends all threads and gets exclusive access to the mutator_lock_.
Mathieu Chartier4f55e222015-09-04 13:26:21 -070072 // If long_suspend is true, then other threads who try to suspend will never timeout.
73 // long_suspend is currenly used for hprof since large heaps take a long time.
Mathieu Chartierbf44d422015-06-02 11:42:18 -070074 void SuspendAll(const char* cause, bool long_suspend = false)
Ian Rogersb726dcb2012-09-05 08:57:23 -070075 EXCLUSIVE_LOCK_FUNCTION(Locks::mutator_lock_)
Mathieu Chartier4f55e222015-09-04 13:26:21 -070076 REQUIRES(!Locks::thread_list_lock_,
77 !Locks::thread_suspend_count_lock_,
78 !Locks::mutator_lock_);
Ian Rogersd9c4fc92013-10-01 19:45:43 -070079
80 // Suspend a thread using a peer, typically used by the debugger. Returns the thread on success,
Mathieu Chartier2cebb242015-04-21 16:50:40 -070081 // else null. The peer is used to identify the thread to avoid races with the thread terminating.
Ian Rogersd9c4fc92013-10-01 19:45:43 -070082 // If the thread should be suspended then value of request_suspension should be true otherwise
83 // the routine will wait for a previous suspend request. If the suspension times out then *timeout
84 // is set to true.
Alex Light46f93402017-06-29 11:59:50 -070085 Thread* SuspendThreadByPeer(jobject peer,
86 bool request_suspension,
87 SuspendReason reason,
Brian Carlstromba32de42014-08-27 23:43:46 -070088 bool* timed_out)
Mathieu Chartierb56200b2015-10-29 10:41:51 -070089 REQUIRES(!Locks::mutator_lock_,
90 !Locks::thread_list_lock_,
Mathieu Chartier90443472015-07-16 20:32:27 -070091 !Locks::thread_suspend_count_lock_);
Ian Rogersd9c4fc92013-10-01 19:45:43 -070092
93 // Suspend a thread using its thread id, typically used by lock/monitor inflation. Returns the
Mathieu Chartier2cebb242015-04-21 16:50:40 -070094 // thread on success else null. The thread id is used to identify the thread to avoid races with
Ian Rogersd9c4fc92013-10-01 19:45:43 -070095 // the thread terminating. Note that as thread ids are recycled this may not suspend the expected
96 // thread, that may be terminating. If the suspension times out then *timeout is set to true.
Alex Light46f93402017-06-29 11:59:50 -070097 Thread* SuspendThreadByThreadId(uint32_t thread_id, SuspendReason reason, bool* timed_out)
Mathieu Chartierb56200b2015-10-29 10:41:51 -070098 REQUIRES(!Locks::mutator_lock_,
99 !Locks::thread_list_lock_,
Mathieu Chartier90443472015-07-16 20:32:27 -0700100 !Locks::thread_suspend_count_lock_);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700101
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700102 // Find an existing thread (or self) by its thread id (not tid).
103 Thread* FindThreadByThreadId(uint32_t thread_id) REQUIRES(Locks::thread_list_lock_);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700104
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700105 // Run a checkpoint on threads, running threads are not suspended but run the checkpoint inside
Mathieu Chartier10d25082015-10-28 18:36:09 -0700106 // of the suspend check. Returns how many checkpoints that are expected to run, including for
Hiroshi Yamauchifebd0cf2016-09-14 19:31:25 -0700107 // already suspended threads for b/24191051. Run the callback, if non-null, inside the
108 // thread_list_lock critical section after determining the runnable/suspended states of the
109 // threads.
110 size_t RunCheckpoint(Closure* checkpoint_function, Closure* callback = nullptr)
Mathieu Chartier90443472015-07-16 20:32:27 -0700111 REQUIRES(!Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700112
Hiroshi Yamauchi30493242016-11-03 13:06:52 -0700113 // Run an empty checkpoint on threads. Wait until threads pass the next suspend point or are
114 // suspended. This is used to ensure that the threads finish or aren't in the middle of an
115 // in-flight mutator heap access (eg. a read barrier.) Runnable threads will respond by
116 // decrementing the empty checkpoint barrier count. This works even when the weak ref access is
117 // disabled. Only one concurrent use is currently supported.
Hiroshi Yamauchia2224042017-02-08 16:35:45 -0800118 void RunEmptyCheckpoint()
Hiroshi Yamauchi30493242016-11-03 13:06:52 -0700119 REQUIRES(!Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_);
120
Ian Rogersa03de6d2014-03-08 23:37:07 +0000121 size_t RunCheckpointOnRunnableThreads(Closure* checkpoint_function)
Mathieu Chartier90443472015-07-16 20:32:27 -0700122 REQUIRES(!Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_);
Dave Allison39c3bfb2014-01-28 18:33:52 -0800123
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800124 // Flip thread roots from from-space refs to to-space refs. Used by
125 // the concurrent copying collector.
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700126 size_t FlipThreadRoots(Closure* thread_flip_visitor,
127 Closure* flip_callback,
Andreas Gampe6e644452017-05-09 16:30:27 -0700128 gc::collector::GarbageCollector* collector,
129 gc::GcPauseListener* pause_listener)
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700130 REQUIRES(!Locks::mutator_lock_,
131 !Locks::thread_list_lock_,
Mathieu Chartier90443472015-07-16 20:32:27 -0700132 !Locks::thread_suspend_count_lock_);
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800133
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700134 // Suspends all threads
135 void SuspendAllForDebugger()
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700136 REQUIRES(!Locks::mutator_lock_,
137 !Locks::thread_list_lock_,
Mathieu Chartier90443472015-07-16 20:32:27 -0700138 !Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700139
140 void SuspendSelfForDebugger()
Mathieu Chartier90443472015-07-16 20:32:27 -0700141 REQUIRES(!Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700142
Sebastien Hertz253fa552014-10-14 17:27:15 +0200143 // Resume all threads
144 void ResumeAllForDebugger()
Mathieu Chartier90443472015-07-16 20:32:27 -0700145 REQUIRES(!Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_);
Sebastien Hertz253fa552014-10-14 17:27:15 +0200146
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700147 void UndoDebuggerSuspensions()
Mathieu Chartier90443472015-07-16 20:32:27 -0700148 REQUIRES(!Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_);
Elliott Hughes8d768a92011-09-14 16:35:25 -0700149
Elliott Hughesf8349362012-06-18 15:00:06 -0700150 // Iterates over all the threads.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700151 void ForEach(void (*callback)(Thread*, void*), void* context)
Mathieu Chartier90443472015-07-16 20:32:27 -0700152 REQUIRES(Locks::thread_list_lock_);
Elliott Hughes47fce012011-10-25 18:37:19 -0700153
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700154 // Add/remove current thread from list.
155 void Register(Thread* self)
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700156 REQUIRES(Locks::runtime_shutdown_lock_)
157 REQUIRES(!Locks::mutator_lock_,
158 !Locks::thread_list_lock_,
Mathieu Chartier90443472015-07-16 20:32:27 -0700159 !Locks::thread_suspend_count_lock_);
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700160 void Unregister(Thread* self)
161 REQUIRES(!Locks::mutator_lock_,
162 !Locks::thread_list_lock_,
163 !Locks::thread_suspend_count_lock_);
Elliott Hughes8daa0922011-09-11 13:46:25 -0700164
Andreas Gampe585da952016-12-02 14:52:29 -0800165 void VisitRoots(RootVisitor* visitor, VisitRootFlags flags) const
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700166 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes8daa0922011-09-11 13:46:25 -0700167
Mathieu Chartierf8a86b92016-06-14 17:08:47 -0700168 void VisitRootsForSuspendedThreads(RootVisitor* visitor)
169 REQUIRES(!Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700170 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartierf8a86b92016-06-14 17:08:47 -0700171
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700172 // Return a copy of the thread list.
Mathieu Chartier90443472015-07-16 20:32:27 -0700173 std::list<Thread*> GetList() REQUIRES(Locks::thread_list_lock_) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700174 return list_;
175 }
Elliott Hughes93e74e82011-09-13 11:07:03 -0700176
Mathieu Chartier590fee92013-09-13 13:46:47 -0700177 void DumpNativeStacks(std::ostream& os)
Mathieu Chartier90443472015-07-16 20:32:27 -0700178 REQUIRES(!Locks::thread_list_lock_);
Mathieu Chartier590fee92013-09-13 13:46:47 -0700179
Hiroshi Yamauchi30493242016-11-03 13:06:52 -0700180 Barrier* EmptyCheckpointBarrier() {
181 return empty_checkpoint_barrier_.get();
182 }
183
Elliott Hughes8daa0922011-09-11 13:46:25 -0700184 private:
Ian Rogerscfaa4552012-11-26 21:00:08 -0800185 uint32_t AllocThreadId(Thread* self);
Mathieu Chartier90443472015-07-16 20:32:27 -0700186 void ReleaseThreadId(Thread* self, uint32_t id) REQUIRES(!Locks::allocated_thread_ids_lock_);
Elliott Hughese52e49b2012-04-02 16:05:44 -0700187
Mathieu Chartier90443472015-07-16 20:32:27 -0700188 bool Contains(Thread* thread) REQUIRES(Locks::thread_list_lock_);
189 bool Contains(pid_t tid) REQUIRES(Locks::thread_list_lock_);
Yu Lieac44242015-06-29 10:50:03 +0800190 size_t RunCheckpoint(Closure* checkpoint_function, bool includeSuspended)
Mathieu Chartier90443472015-07-16 20:32:27 -0700191 REQUIRES(!Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_);
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700192
Nicolas Geoffrayd3c59652016-03-17 09:35:04 +0000193 void DumpUnattachedThreads(std::ostream& os, bool dump_native_stack)
Mathieu Chartier90443472015-07-16 20:32:27 -0700194 REQUIRES(!Locks::thread_list_lock_);
Elliott Hughese52e49b2012-04-02 16:05:44 -0700195
Mathieu Chartier4d87df62016-01-07 15:14:19 -0800196 void SuspendAllDaemonThreadsForShutdown()
Mathieu Chartier90443472015-07-16 20:32:27 -0700197 REQUIRES(!Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700198 void WaitForOtherNonDaemonThreadsToExit()
Mathieu Chartier90443472015-07-16 20:32:27 -0700199 REQUIRES(!Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_);
Elliott Hughes8daa0922011-09-11 13:46:25 -0700200
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700201 void SuspendAllInternal(Thread* self,
202 Thread* ignore1,
203 Thread* ignore2 = nullptr,
Alex Light46f93402017-06-29 11:59:50 -0700204 SuspendReason reason = SuspendReason::kInternal)
Mathieu Chartier90443472015-07-16 20:32:27 -0700205 REQUIRES(!Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_);
Yu Lieac44242015-06-29 10:50:03 +0800206
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700207 void AssertThreadsAreSuspended(Thread* self, Thread* ignore1, Thread* ignore2 = nullptr)
Mathieu Chartier90443472015-07-16 20:32:27 -0700208 REQUIRES(!Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_);
Elliott Hughes234ab152011-10-26 14:02:26 -0700209
Chao-ying Fu9e369312014-05-21 11:20:52 -0700210 std::bitset<kMaxThreadId> allocated_ids_ GUARDED_BY(Locks::allocated_thread_ids_lock_);
Elliott Hughese52e49b2012-04-02 16:05:44 -0700211
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700212 // The actual list of all threads.
Ian Rogersb726dcb2012-09-05 08:57:23 -0700213 std::list<Thread*> list_ GUARDED_BY(Locks::thread_list_lock_);
Elliott Hughes8daa0922011-09-11 13:46:25 -0700214
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700215 // Ongoing suspend all requests, used to ensure threads added to list_ respect SuspendAll.
Ian Rogersb726dcb2012-09-05 08:57:23 -0700216 int suspend_all_count_ GUARDED_BY(Locks::thread_suspend_count_lock_);
217 int debug_suspend_all_count_ GUARDED_BY(Locks::thread_suspend_count_lock_);
Elliott Hughes8d768a92011-09-14 16:35:25 -0700218
Mathieu Chartier91e56692015-03-03 13:51:04 -0800219 // Number of threads unregistering, ~ThreadList blocks until this hits 0.
220 int unregistering_count_ GUARDED_BY(Locks::thread_list_lock_);
Elliott Hughes93e74e82011-09-13 11:07:03 -0700221
Mathieu Chartier70a596d2014-12-17 14:56:47 -0800222 // Thread suspend time histogram. Only modified when all the threads are suspended, so guarding
223 // by mutator lock ensures no thread can read when another thread is modifying it.
224 Histogram<uint64_t> suspend_all_historam_ GUARDED_BY(Locks::mutator_lock_);
225
Mathieu Chartierbf44d422015-06-02 11:42:18 -0700226 // Whether or not the current thread suspension is long.
227 bool long_suspend_;
228
Andreas Gampec4bed162017-05-01 13:46:24 -0700229 // Whether the shutdown function has been called. This is checked in the destructor. It is an
230 // error to destroy a ThreadList instance without first calling ShutDown().
231 bool shut_down_;
232
Mathieu Chartier3fceaf52017-01-22 13:33:40 -0800233 // Thread suspension timeout in nanoseconds.
234 const uint64_t thread_suspend_timeout_ns_;
235
Hiroshi Yamauchi30493242016-11-03 13:06:52 -0700236 std::unique_ptr<Barrier> empty_checkpoint_barrier_;
237
Elliott Hughes8daa0922011-09-11 13:46:25 -0700238 friend class Thread;
Elliott Hughes8daa0922011-09-11 13:46:25 -0700239
240 DISALLOW_COPY_AND_ASSIGN(ThreadList);
241};
242
Mathieu Chartier4f55e222015-09-04 13:26:21 -0700243// Helper for suspending all threads and
244class ScopedSuspendAll : public ValueObject {
245 public:
Chih-Hung Hsieha5931182016-09-01 15:08:13 -0700246 explicit ScopedSuspendAll(const char* cause, bool long_suspend = false)
Mathieu Chartier4f55e222015-09-04 13:26:21 -0700247 EXCLUSIVE_LOCK_FUNCTION(Locks::mutator_lock_)
248 REQUIRES(!Locks::thread_list_lock_,
249 !Locks::thread_suspend_count_lock_,
250 !Locks::mutator_lock_);
251 // No REQUIRES(mutator_lock_) since the unlock function already asserts this.
252 ~ScopedSuspendAll()
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700253 REQUIRES(!Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_)
254 UNLOCK_FUNCTION(Locks::mutator_lock_);
Mathieu Chartier4f55e222015-09-04 13:26:21 -0700255};
256
Elliott Hughes8daa0922011-09-11 13:46:25 -0700257} // namespace art
258
Brian Carlstromfc0e3212013-07-17 14:40:12 -0700259#endif // ART_RUNTIME_THREAD_LIST_H_