blob: 3efdab6c4ecb50c678c31cd7a2906419957247d2 [file] [log] [blame]
Elliott Hughes5f791332011-09-15 17:45:30 -07001/*
2 * Copyright (C) 2008 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
Elliott Hughes54e7df12011-09-16 11:47:04 -070017#include "monitor.h"
Elliott Hughes5f791332011-09-15 17:45:30 -070018
19#include <errno.h>
20#include <fcntl.h>
21#include <pthread.h>
22#include <stdlib.h>
23#include <sys/time.h>
24#include <time.h>
25#include <unistd.h>
26
jeffhao33dc7712011-11-09 17:54:24 -080027#include "class_linker.h"
Elliott Hughes5f791332011-09-15 17:45:30 -070028#include "mutex.h"
29#include "object.h"
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080030#include "object_utils.h"
Elliott Hughesc33a32b2011-10-11 18:18:07 -070031#include "stl_util.h"
Elliott Hughes5f791332011-09-15 17:45:30 -070032#include "thread.h"
Elliott Hughes8e4aac52011-09-26 17:03:36 -070033#include "thread_list.h"
Elliott Hughes5f791332011-09-15 17:45:30 -070034
35namespace art {
36
37/*
38 * Every Object has a monitor associated with it, but not every Object is
39 * actually locked. Even the ones that are locked do not need a
40 * full-fledged monitor until a) there is actual contention or b) wait()
41 * is called on the Object.
42 *
43 * For Android, we have implemented a scheme similar to the one described
44 * in Bacon et al.'s "Thin locks: featherweight synchronization for Java"
45 * (ACM 1998). Things are even easier for us, though, because we have
46 * a full 32 bits to work with.
47 *
48 * The two states of an Object's lock are referred to as "thin" and
49 * "fat". A lock may transition from the "thin" state to the "fat"
50 * state and this transition is referred to as inflation. Once a lock
51 * has been inflated it remains in the "fat" state indefinitely.
52 *
53 * The lock value itself is stored in Object.lock. The LSB of the
54 * lock encodes its state. When cleared, the lock is in the "thin"
55 * state and its bits are formatted as follows:
56 *
57 * [31 ---- 19] [18 ---- 3] [2 ---- 1] [0]
58 * lock count thread id hash state 0
59 *
60 * When set, the lock is in the "fat" state and its bits are formatted
61 * as follows:
62 *
63 * [31 ---- 3] [2 ---- 1] [0]
64 * pointer hash state 1
65 *
66 * For an in-depth description of the mechanics of thin-vs-fat locking,
67 * read the paper referred to above.
Elliott Hughes54e7df12011-09-16 11:47:04 -070068 *
Elliott Hughes5f791332011-09-15 17:45:30 -070069 * Monitors provide:
70 * - mutually exclusive access to resources
71 * - a way for multiple threads to wait for notification
72 *
73 * In effect, they fill the role of both mutexes and condition variables.
74 *
75 * Only one thread can own the monitor at any time. There may be several
76 * threads waiting on it (the wait call unlocks it). One or more waiting
77 * threads may be getting interrupted or notified at any given time.
78 *
79 * TODO: the various members of monitor are not SMP-safe.
80 */
Elliott Hughes54e7df12011-09-16 11:47:04 -070081
82
83/*
84 * Monitor accessor. Extracts a monitor structure pointer from a fat
85 * lock. Performs no error checking.
86 */
87#define LW_MONITOR(x) \
88 ((Monitor*)((x) & ~((LW_HASH_STATE_MASK << LW_HASH_STATE_SHIFT) | LW_SHAPE_MASK)))
89
90/*
91 * Lock recursion count field. Contains a count of the number of times
92 * a lock has been recursively acquired.
93 */
94#define LW_LOCK_COUNT_MASK 0x1fff
95#define LW_LOCK_COUNT_SHIFT 19
96#define LW_LOCK_COUNT(x) (((x) >> LW_LOCK_COUNT_SHIFT) & LW_LOCK_COUNT_MASK)
97
Elliott Hughesfc861622011-10-17 17:57:47 -070098bool (*Monitor::is_sensitive_thread_hook_)() = NULL;
Elliott Hughesfc861622011-10-17 17:57:47 -070099uint32_t Monitor::lock_profiling_threshold_ = 0;
Elliott Hughes32d6e1e2011-10-11 14:47:44 -0700100
Elliott Hughesfc861622011-10-17 17:57:47 -0700101bool Monitor::IsSensitiveThread() {
102 if (is_sensitive_thread_hook_ != NULL) {
103 return (*is_sensitive_thread_hook_)();
104 }
105 return false;
106}
107
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800108void Monitor::Init(uint32_t lock_profiling_threshold, bool (*is_sensitive_thread_hook)()) {
Elliott Hughesfc861622011-10-17 17:57:47 -0700109 lock_profiling_threshold_ = lock_profiling_threshold;
110 is_sensitive_thread_hook_ = is_sensitive_thread_hook;
Elliott Hughes32d6e1e2011-10-11 14:47:44 -0700111}
112
Elliott Hughes5f791332011-09-15 17:45:30 -0700113Monitor::Monitor(Object* obj)
114 : owner_(NULL),
115 lock_count_(0),
116 obj_(obj),
117 wait_set_(NULL),
118 lock_("a monitor lock"),
jeffhao33dc7712011-11-09 17:54:24 -0800119 locking_method_(NULL),
120 locking_pc_(0) {
Elliott Hughes5f791332011-09-15 17:45:30 -0700121}
122
123Monitor::~Monitor() {
124 DCHECK(obj_ != NULL);
125 DCHECK_EQ(LW_SHAPE(*obj_->GetRawLockWordAddress()), LW_SHAPE_FAT);
Elliott Hughes5f791332011-09-15 17:45:30 -0700126}
127
128/*
129 * Links a thread into a monitor's wait set. The monitor lock must be
130 * held by the caller of this routine.
131 */
132void Monitor::AppendToWaitSet(Thread* thread) {
133 DCHECK(owner_ == Thread::Current());
134 DCHECK(thread != NULL);
Elliott Hughesdc33ad52011-09-16 19:46:51 -0700135 DCHECK(thread->wait_next_ == NULL) << thread->wait_next_;
Elliott Hughes5f791332011-09-15 17:45:30 -0700136 if (wait_set_ == NULL) {
137 wait_set_ = thread;
138 return;
139 }
140
141 // push_back.
142 Thread* t = wait_set_;
143 while (t->wait_next_ != NULL) {
144 t = t->wait_next_;
145 }
146 t->wait_next_ = thread;
147}
148
149/*
150 * Unlinks a thread from a monitor's wait set. The monitor lock must
151 * be held by the caller of this routine.
152 */
153void Monitor::RemoveFromWaitSet(Thread *thread) {
154 DCHECK(owner_ == Thread::Current());
155 DCHECK(thread != NULL);
156 if (wait_set_ == NULL) {
157 return;
158 }
159 if (wait_set_ == thread) {
160 wait_set_ = thread->wait_next_;
161 thread->wait_next_ = NULL;
162 return;
163 }
164
165 Thread* t = wait_set_;
166 while (t->wait_next_ != NULL) {
167 if (t->wait_next_ == thread) {
168 t->wait_next_ = thread->wait_next_;
169 thread->wait_next_ = NULL;
170 return;
171 }
172 t = t->wait_next_;
173 }
174}
175
Elliott Hughesc33a32b2011-10-11 18:18:07 -0700176Object* Monitor::GetObject() {
177 return obj_;
Elliott Hughes5f791332011-09-15 17:45:30 -0700178}
179
Elliott Hughes5f791332011-09-15 17:45:30 -0700180void Monitor::Lock(Thread* self) {
Elliott Hughes5f791332011-09-15 17:45:30 -0700181 if (owner_ == self) {
182 lock_count_++;
183 return;
184 }
Elliott Hughesfc861622011-10-17 17:57:47 -0700185
186 uint64_t waitStart, waitEnd;
Elliott Hughes5f791332011-09-15 17:45:30 -0700187 if (!lock_.TryLock()) {
Elliott Hughesfc861622011-10-17 17:57:47 -0700188 uint32_t wait_threshold = lock_profiling_threshold_;
jeffhao33dc7712011-11-09 17:54:24 -0800189 const Method* current_locking_method = NULL;
Elliott Hughese65a6c92012-01-18 23:48:31 -0800190 uintptr_t current_locking_pc = 0;
Elliott Hughes5f791332011-09-15 17:45:30 -0700191 {
192 ScopedThreadStateChange tsc(self, Thread::kBlocked);
Elliott Hughesfc861622011-10-17 17:57:47 -0700193 if (wait_threshold != 0) {
194 waitStart = NanoTime() / 1000;
195 }
jeffhao33dc7712011-11-09 17:54:24 -0800196 current_locking_method = locking_method_;
197 current_locking_pc = locking_pc_;
Elliott Hughes5f791332011-09-15 17:45:30 -0700198
199 lock_.Lock();
Elliott Hughesfc861622011-10-17 17:57:47 -0700200 if (wait_threshold != 0) {
201 waitEnd = NanoTime() / 1000;
202 }
Elliott Hughes5f791332011-09-15 17:45:30 -0700203 }
Elliott Hughesfc861622011-10-17 17:57:47 -0700204
205 if (wait_threshold != 0) {
206 uint64_t wait_ms = (waitEnd - waitStart) / 1000;
207 uint32_t sample_percent;
208 if (wait_ms >= wait_threshold) {
209 sample_percent = 100;
210 } else {
211 sample_percent = 100 * wait_ms / wait_threshold;
212 }
213 if (sample_percent != 0 && (static_cast<uint32_t>(rand() % 100) < sample_percent)) {
jeffhao33dc7712011-11-09 17:54:24 -0800214 const char* current_locking_filename;
215 uint32_t current_locking_line_number;
216 TranslateLocation(current_locking_method, current_locking_pc,
217 current_locking_filename, current_locking_line_number);
218 LogContentionEvent(self, wait_ms, sample_percent, current_locking_filename, current_locking_line_number);
Elliott Hughesfc861622011-10-17 17:57:47 -0700219 }
220 }
Elliott Hughes5f791332011-09-15 17:45:30 -0700221 }
222 owner_ = self;
223 DCHECK_EQ(lock_count_, 0);
224
225 // When debugging, save the current monitor holder for future
226 // acquisition failures to use in sampled logging.
Elliott Hughesfc861622011-10-17 17:57:47 -0700227 if (lock_profiling_threshold_ != 0) {
Elliott Hughesd07986f2011-12-06 18:27:45 -0800228 locking_method_ = self->GetCurrentMethod(&locking_pc_);
Elliott Hughesfc861622011-10-17 17:57:47 -0700229 }
Elliott Hughes5f791332011-09-15 17:45:30 -0700230}
231
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800232static void ThrowIllegalMonitorStateExceptionF(const char* fmt, ...)
233 __attribute__((format(printf, 1, 2)));
234
235static void ThrowIllegalMonitorStateExceptionF(const char* fmt, ...) {
236 va_list args;
237 va_start(args, fmt);
238 Thread::Current()->ThrowNewExceptionV("Ljava/lang/IllegalMonitorStateException;", fmt, args);
239 va_end(args);
240}
241
Elliott Hughesd4237412012-02-21 11:24:45 -0800242static std::string ThreadToString(Thread* thread) {
243 if (thread == NULL) {
244 return "NULL";
245 }
246 std::ostringstream oss;
247 // TODO: alternatively, we could just return the thread's name.
248 oss << *thread;
249 return oss.str();
250}
251
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800252void Monitor::FailedUnlock(Object* obj, Thread* expected_owner, Thread* found_owner,
253 Monitor* mon) {
254 // Acquire thread list lock so threads won't disappear from under us
255 ScopedThreadListLock tll;
256 // Re-read owner now that we hold lock
257 Thread* current_owner = mon != NULL ? mon->owner_ : NULL;
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800258 if (current_owner == NULL) {
259 if (found_owner == NULL) {
260 ThrowIllegalMonitorStateExceptionF("unlock of unowned monitor on object of type '%s'"
261 " on thread '%s'",
Elliott Hughesd4237412012-02-21 11:24:45 -0800262 PrettyTypeOf(obj).c_str(),
263 ThreadToString(expected_owner).c_str());
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800264 } else {
265 // Race: the original read found an owner but now there is none
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800266 ThrowIllegalMonitorStateExceptionF("unlock of monitor owned by '%s' on object of type '%s'"
267 " (where now the monitor appears unowned) on thread '%s'",
Elliott Hughesd4237412012-02-21 11:24:45 -0800268 ThreadToString(found_owner).c_str(),
269 PrettyTypeOf(obj).c_str(),
270 ThreadToString(expected_owner).c_str());
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800271 }
272 } else {
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800273 if (found_owner == NULL) {
274 // Race: originally there was no owner, there is now
275 ThrowIllegalMonitorStateExceptionF("unlock of monitor owned by '%s' on object of type '%s'"
276 " (originally believed to be unowned) on thread '%s'",
Elliott Hughesd4237412012-02-21 11:24:45 -0800277 ThreadToString(current_owner).c_str(),
278 PrettyTypeOf(obj).c_str(),
279 ThreadToString(expected_owner).c_str());
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800280 } else {
281 if (found_owner != current_owner) {
282 // Race: originally found and current owner have changed
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800283 ThrowIllegalMonitorStateExceptionF("unlock of monitor originally owned by '%s' (now"
284 " owned by '%s') on object of type '%s' on thread '%s'",
Elliott Hughesd4237412012-02-21 11:24:45 -0800285 ThreadToString(found_owner).c_str(),
286 ThreadToString(current_owner).c_str(),
287 PrettyTypeOf(obj).c_str(),
288 ThreadToString(expected_owner).c_str());
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800289 } else {
290 ThrowIllegalMonitorStateExceptionF("unlock of monitor owned by '%s' on object of type '%s'"
291 " on thread '%s",
Elliott Hughesd4237412012-02-21 11:24:45 -0800292 ThreadToString(current_owner).c_str(),
293 PrettyTypeOf(obj).c_str(),
294 ThreadToString(expected_owner).c_str());
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800295 }
296 }
297 }
Elliott Hughes5f791332011-09-15 17:45:30 -0700298}
299
300bool Monitor::Unlock(Thread* self) {
301 DCHECK(self != NULL);
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800302 Thread* owner = owner_;
303 if (owner == self) {
Elliott Hughes5f791332011-09-15 17:45:30 -0700304 // We own the monitor, so nobody else can be in here.
305 if (lock_count_ == 0) {
306 owner_ = NULL;
jeffhao33dc7712011-11-09 17:54:24 -0800307 locking_method_ = NULL;
308 locking_pc_ = 0;
Elliott Hughes5f791332011-09-15 17:45:30 -0700309 lock_.Unlock();
310 } else {
311 --lock_count_;
312 }
313 } else {
314 // We don't own this, so we're not allowed to unlock it.
315 // The JNI spec says that we should throw IllegalMonitorStateException
316 // in this case.
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800317 FailedUnlock(obj_, self, owner, this);
Elliott Hughes5f791332011-09-15 17:45:30 -0700318 return false;
319 }
320 return true;
321}
322
323/*
324 * Converts the given relative waiting time into an absolute time.
325 */
326void ToAbsoluteTime(int64_t ms, int32_t ns, struct timespec *ts) {
327 int64_t endSec;
328
329#ifdef HAVE_TIMEDWAIT_MONOTONIC
330 clock_gettime(CLOCK_MONOTONIC, ts);
331#else
332 {
333 struct timeval tv;
334 gettimeofday(&tv, NULL);
335 ts->tv_sec = tv.tv_sec;
336 ts->tv_nsec = tv.tv_usec * 1000;
337 }
338#endif
339 endSec = ts->tv_sec + ms / 1000;
340 if (endSec >= 0x7fffffff) {
341 LOG(INFO) << "Note: end time exceeds epoch";
342 endSec = 0x7ffffffe;
343 }
344 ts->tv_sec = endSec;
345 ts->tv_nsec = (ts->tv_nsec + (ms % 1000) * 1000000) + ns;
346
347 // Catch rollover.
348 if (ts->tv_nsec >= 1000000000L) {
349 ts->tv_sec++;
350 ts->tv_nsec -= 1000000000L;
351 }
352}
353
354int dvmRelativeCondWait(pthread_cond_t* cond, pthread_mutex_t* mutex, int64_t ms, int32_t ns) {
355 struct timespec ts;
356 ToAbsoluteTime(ms, ns, &ts);
357#if defined(HAVE_TIMEDWAIT_MONOTONIC)
358 int rc = pthread_cond_timedwait_monotonic(cond, mutex, &ts);
359#else
360 int rc = pthread_cond_timedwait(cond, mutex, &ts);
361#endif
362 DCHECK(rc == 0 || rc == ETIMEDOUT);
363 return rc;
364}
365
366/*
367 * Wait on a monitor until timeout, interrupt, or notification. Used for
368 * Object.wait() and (somewhat indirectly) Thread.sleep() and Thread.join().
369 *
370 * If another thread calls Thread.interrupt(), we throw InterruptedException
371 * and return immediately if one of the following are true:
372 * - blocked in wait(), wait(long), or wait(long, int) methods of Object
373 * - blocked in join(), join(long), or join(long, int) methods of Thread
374 * - blocked in sleep(long), or sleep(long, int) methods of Thread
375 * Otherwise, we set the "interrupted" flag.
376 *
377 * Checks to make sure that "ns" is in the range 0-999999
378 * (i.e. fractions of a millisecond) and throws the appropriate
379 * exception if it isn't.
380 *
381 * The spec allows "spurious wakeups", and recommends that all code using
382 * Object.wait() do so in a loop. This appears to derive from concerns
383 * about pthread_cond_wait() on multiprocessor systems. Some commentary
384 * on the web casts doubt on whether these can/should occur.
385 *
386 * Since we're allowed to wake up "early", we clamp extremely long durations
387 * to return at the end of the 32-bit time epoch.
388 */
389void Monitor::Wait(Thread* self, int64_t ms, int32_t ns, bool interruptShouldThrow) {
390 DCHECK(self != NULL);
391
392 // Make sure that we hold the lock.
393 if (owner_ != self) {
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800394 ThrowIllegalMonitorStateExceptionF("object not locked by thread before wait()");
Elliott Hughes5f791332011-09-15 17:45:30 -0700395 return;
396 }
397
398 // Enforce the timeout range.
399 if (ms < 0 || ns < 0 || ns > 999999) {
Elliott Hughes5cb5ad22011-10-02 12:13:39 -0700400 Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalArgumentException;",
Elliott Hughes5f791332011-09-15 17:45:30 -0700401 "timeout arguments out of range: ms=%lld ns=%d", ms, ns);
402 return;
403 }
404
405 // Compute absolute wakeup time, if necessary.
406 struct timespec ts;
407 bool timed = false;
408 if (ms != 0 || ns != 0) {
409 ToAbsoluteTime(ms, ns, &ts);
410 timed = true;
411 }
412
413 /*
414 * Add ourselves to the set of threads waiting on this monitor, and
415 * release our hold. We need to let it go even if we're a few levels
416 * deep in a recursive lock, and we need to restore that later.
417 *
418 * We append to the wait set ahead of clearing the count and owner
419 * fields so the subroutine can check that the calling thread owns
420 * the monitor. Aside from that, the order of member updates is
421 * not order sensitive as we hold the pthread mutex.
422 */
423 AppendToWaitSet(self);
424 int prevLockCount = lock_count_;
425 lock_count_ = 0;
426 owner_ = NULL;
jeffhao33dc7712011-11-09 17:54:24 -0800427 const Method* savedMethod = locking_method_;
428 locking_method_ = NULL;
Elliott Hughese65a6c92012-01-18 23:48:31 -0800429 uintptr_t savedPc = locking_pc_;
jeffhao33dc7712011-11-09 17:54:24 -0800430 locking_pc_ = 0;
Elliott Hughes5f791332011-09-15 17:45:30 -0700431
432 /*
433 * Update thread status. If the GC wakes up, it'll ignore us, knowing
434 * that we won't touch any references in this state, and we'll check
435 * our suspend mode before we transition out.
436 */
437 if (timed) {
438 self->SetState(Thread::kTimedWaiting);
439 } else {
440 self->SetState(Thread::kWaiting);
441 }
442
Elliott Hughes85d15452011-09-16 17:33:01 -0700443 self->wait_mutex_->Lock();
Elliott Hughes5f791332011-09-15 17:45:30 -0700444
445 /*
446 * Set wait_monitor_ to the monitor object we will be waiting on.
447 * When wait_monitor_ is non-NULL a notifying or interrupting thread
448 * must signal the thread's wait_cond_ to wake it up.
449 */
450 DCHECK(self->wait_monitor_ == NULL);
451 self->wait_monitor_ = this;
452
453 /*
454 * Handle the case where the thread was interrupted before we called
455 * wait().
456 */
457 bool wasInterrupted = false;
458 if (self->interrupted_) {
459 wasInterrupted = true;
460 self->wait_monitor_ = NULL;
Elliott Hughes85d15452011-09-16 17:33:01 -0700461 self->wait_mutex_->Unlock();
Elliott Hughes5f791332011-09-15 17:45:30 -0700462 goto done;
463 }
464
465 /*
466 * Release the monitor lock and wait for a notification or
467 * a timeout to occur.
468 */
469 lock_.Unlock();
470
471 if (!timed) {
Elliott Hughes85d15452011-09-16 17:33:01 -0700472 self->wait_cond_->Wait(*self->wait_mutex_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700473 } else {
Elliott Hughes85d15452011-09-16 17:33:01 -0700474 self->wait_cond_->TimedWait(*self->wait_mutex_, ts);
Elliott Hughes5f791332011-09-15 17:45:30 -0700475 }
476 if (self->interrupted_) {
477 wasInterrupted = true;
478 }
479
480 self->interrupted_ = false;
481 self->wait_monitor_ = NULL;
Elliott Hughes85d15452011-09-16 17:33:01 -0700482 self->wait_mutex_->Unlock();
Elliott Hughes5f791332011-09-15 17:45:30 -0700483
484 // Reacquire the monitor lock.
485 Lock(self);
486
487done:
488 /*
489 * We remove our thread from wait set after restoring the count
490 * and owner fields so the subroutine can check that the calling
491 * thread owns the monitor. Aside from that, the order of member
492 * updates is not order sensitive as we hold the pthread mutex.
493 */
494 owner_ = self;
495 lock_count_ = prevLockCount;
jeffhao33dc7712011-11-09 17:54:24 -0800496 locking_method_ = savedMethod;
497 locking_pc_ = savedPc;
Elliott Hughes5f791332011-09-15 17:45:30 -0700498 RemoveFromWaitSet(self);
499
500 /* set self->status back to Thread::kRunnable, and self-suspend if needed */
501 self->SetState(Thread::kRunnable);
502
503 if (wasInterrupted) {
504 /*
505 * We were interrupted while waiting, or somebody interrupted an
506 * un-interruptible thread earlier and we're bailing out immediately.
507 *
508 * The doc sayeth: "The interrupted status of the current thread is
509 * cleared when this exception is thrown."
510 */
511 self->interrupted_ = false;
512 if (interruptShouldThrow) {
Elliott Hughes5cb5ad22011-10-02 12:13:39 -0700513 Thread::Current()->ThrowNewException("Ljava/lang/InterruptedException;", NULL);
Elliott Hughes5f791332011-09-15 17:45:30 -0700514 }
515 }
516}
517
518void Monitor::Notify(Thread* self) {
519 DCHECK(self != NULL);
520
521 // Make sure that we hold the lock.
522 if (owner_ != self) {
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800523 ThrowIllegalMonitorStateExceptionF("object not locked by thread before notify()");
Elliott Hughes5f791332011-09-15 17:45:30 -0700524 return;
525 }
526 // Signal the first waiting thread in the wait set.
527 while (wait_set_ != NULL) {
528 Thread* thread = wait_set_;
529 wait_set_ = thread->wait_next_;
530 thread->wait_next_ = NULL;
531
532 // Check to see if the thread is still waiting.
Elliott Hughes85d15452011-09-16 17:33:01 -0700533 MutexLock mu(*thread->wait_mutex_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700534 if (thread->wait_monitor_ != NULL) {
Elliott Hughes85d15452011-09-16 17:33:01 -0700535 thread->wait_cond_->Signal();
Elliott Hughes5f791332011-09-15 17:45:30 -0700536 return;
537 }
538 }
539}
540
541void Monitor::NotifyAll(Thread* self) {
542 DCHECK(self != NULL);
543
544 // Make sure that we hold the lock.
545 if (owner_ != self) {
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800546 ThrowIllegalMonitorStateExceptionF("object not locked by thread before notifyAll()");
Elliott Hughes5f791332011-09-15 17:45:30 -0700547 return;
548 }
549 // Signal all threads in the wait set.
550 while (wait_set_ != NULL) {
551 Thread* thread = wait_set_;
552 wait_set_ = thread->wait_next_;
553 thread->wait_next_ = NULL;
554 thread->Notify();
555 }
556}
557
558/*
559 * Changes the shape of a monitor from thin to fat, preserving the
560 * internal lock state. The calling thread must own the lock.
561 */
562void Monitor::Inflate(Thread* self, Object* obj) {
563 DCHECK(self != NULL);
564 DCHECK(obj != NULL);
565 DCHECK_EQ(LW_SHAPE(*obj->GetRawLockWordAddress()), LW_SHAPE_THIN);
Elliott Hughesf8e01272011-10-17 11:29:05 -0700566 DCHECK_EQ(LW_LOCK_OWNER(*obj->GetRawLockWordAddress()), static_cast<int32_t>(self->GetThinLockId()));
Elliott Hughes5f791332011-09-15 17:45:30 -0700567
568 // Allocate and acquire a new monitor.
569 Monitor* m = new Monitor(obj);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800570 VLOG(monitor) << "monitor: thread " << self->GetThinLockId()
571 << " created monitor " << m << " for object " << obj;
Elliott Hughesc33a32b2011-10-11 18:18:07 -0700572 Runtime::Current()->GetMonitorList()->Add(m);
Elliott Hughes5f791332011-09-15 17:45:30 -0700573 m->Lock(self);
574 // Propagate the lock state.
575 uint32_t thin = *obj->GetRawLockWordAddress();
576 m->lock_count_ = LW_LOCK_COUNT(thin);
577 thin &= LW_HASH_STATE_MASK << LW_HASH_STATE_SHIFT;
578 thin |= reinterpret_cast<uint32_t>(m) | LW_SHAPE_FAT;
579 // Publish the updated lock word.
580 android_atomic_release_store(thin, obj->GetRawLockWordAddress());
581}
582
583void Monitor::MonitorEnter(Thread* self, Object* obj) {
584 volatile int32_t* thinp = obj->GetRawLockWordAddress();
585 struct timespec tm;
586 long sleepDelayNs;
587 long minSleepDelayNs = 1000000; /* 1 millisecond */
588 long maxSleepDelayNs = 1000000000; /* 1 second */
Elliott Hughesf8e01272011-10-17 11:29:05 -0700589 uint32_t thin, newThin;
Elliott Hughes5f791332011-09-15 17:45:30 -0700590
Elliott Hughes4681c802011-09-25 18:04:37 -0700591 DCHECK(self != NULL);
592 DCHECK(obj != NULL);
Elliott Hughesf8e01272011-10-17 11:29:05 -0700593 uint32_t threadId = self->GetThinLockId();
Elliott Hughes5f791332011-09-15 17:45:30 -0700594retry:
595 thin = *thinp;
596 if (LW_SHAPE(thin) == LW_SHAPE_THIN) {
597 /*
598 * The lock is a thin lock. The owner field is used to
599 * determine the acquire method, ordered by cost.
600 */
601 if (LW_LOCK_OWNER(thin) == threadId) {
602 /*
603 * The calling thread owns the lock. Increment the
604 * value of the recursion count field.
605 */
606 *thinp += 1 << LW_LOCK_COUNT_SHIFT;
607 if (LW_LOCK_COUNT(*thinp) == LW_LOCK_COUNT_MASK) {
608 /*
609 * The reacquisition limit has been reached. Inflate
610 * the lock so the next acquire will not overflow the
611 * recursion count field.
612 */
613 Inflate(self, obj);
614 }
615 } else if (LW_LOCK_OWNER(thin) == 0) {
616 /*
617 * The lock is unowned. Install the thread id of the
618 * calling thread into the owner field. This is the
619 * common case. In performance critical code the JIT
620 * will have tried this before calling out to the VM.
621 */
622 newThin = thin | (threadId << LW_LOCK_OWNER_SHIFT);
623 if (android_atomic_acquire_cas(thin, newThin, thinp) != 0) {
624 // The acquire failed. Try again.
625 goto retry;
626 }
627 } else {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800628 VLOG(monitor) << StringPrintf("monitor: thread %d spin on lock %p (a %s) owned by %d",
629 threadId, thinp, PrettyTypeOf(obj).c_str(), LW_LOCK_OWNER(thin));
Elliott Hughes5f791332011-09-15 17:45:30 -0700630 // The lock is owned by another thread. Notify the VM that we are about to wait.
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700631 self->monitor_enter_object_ = obj;
Elliott Hughes5f791332011-09-15 17:45:30 -0700632 Thread::State oldStatus = self->SetState(Thread::kBlocked);
633 // Spin until the thin lock is released or inflated.
634 sleepDelayNs = 0;
635 for (;;) {
636 thin = *thinp;
637 // Check the shape of the lock word. Another thread
638 // may have inflated the lock while we were waiting.
639 if (LW_SHAPE(thin) == LW_SHAPE_THIN) {
640 if (LW_LOCK_OWNER(thin) == 0) {
641 // The lock has been released. Install the thread id of the
642 // calling thread into the owner field.
643 newThin = thin | (threadId << LW_LOCK_OWNER_SHIFT);
644 if (android_atomic_acquire_cas(thin, newThin, thinp) == 0) {
645 // The acquire succeed. Break out of the loop and proceed to inflate the lock.
646 break;
647 }
648 } else {
649 // The lock has not been released. Yield so the owning thread can run.
650 if (sleepDelayNs == 0) {
651 sched_yield();
652 sleepDelayNs = minSleepDelayNs;
653 } else {
654 tm.tv_sec = 0;
655 tm.tv_nsec = sleepDelayNs;
656 nanosleep(&tm, NULL);
657 // Prepare the next delay value. Wrap to avoid once a second polls for eternity.
658 if (sleepDelayNs < maxSleepDelayNs / 2) {
659 sleepDelayNs *= 2;
660 } else {
661 sleepDelayNs = minSleepDelayNs;
662 }
663 }
664 }
665 } else {
666 // The thin lock was inflated by another thread. Let the VM know we are no longer
667 // waiting and try again.
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800668 VLOG(monitor) << "monitor: thread " << threadId
669 << " found lock " << (void*) thinp << " surprise-fattened by another thread";
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700670 self->monitor_enter_object_ = NULL;
Elliott Hughes5f791332011-09-15 17:45:30 -0700671 self->SetState(oldStatus);
672 goto retry;
673 }
674 }
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800675 VLOG(monitor) << StringPrintf("monitor: thread %d spin on lock %p done", threadId, thinp);
Elliott Hughes5f791332011-09-15 17:45:30 -0700676 // We have acquired the thin lock. Let the VM know that we are no longer waiting.
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700677 self->monitor_enter_object_ = NULL;
Elliott Hughes5f791332011-09-15 17:45:30 -0700678 self->SetState(oldStatus);
679 // Fatten the lock.
680 Inflate(self, obj);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800681 VLOG(monitor) << StringPrintf("monitor: thread %d fattened lock %p", threadId, thinp);
Elliott Hughes5f791332011-09-15 17:45:30 -0700682 }
683 } else {
684 // The lock is a fat lock.
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800685 VLOG(monitor) << StringPrintf("monitor: thread %d locking fat lock %p (%p) %p on a %s",
Elliott Hughesf8e01272011-10-17 11:29:05 -0700686 threadId, thinp, LW_MONITOR(*thinp), (void*)*thinp, PrettyTypeOf(obj).c_str());
Elliott Hughes5f791332011-09-15 17:45:30 -0700687 DCHECK(LW_MONITOR(*thinp) != NULL);
688 LW_MONITOR(*thinp)->Lock(self);
689 }
690}
691
692bool Monitor::MonitorExit(Thread* self, Object* obj) {
693 volatile int32_t* thinp = obj->GetRawLockWordAddress();
694
695 DCHECK(self != NULL);
Elliott Hughes4681c802011-09-25 18:04:37 -0700696 //DCHECK_EQ(self->GetState(), Thread::kRunnable);
Elliott Hughes5f791332011-09-15 17:45:30 -0700697 DCHECK(obj != NULL);
698
699 /*
700 * Cache the lock word as its value can change while we are
701 * examining its state.
702 */
703 uint32_t thin = *thinp;
704 if (LW_SHAPE(thin) == LW_SHAPE_THIN) {
705 /*
706 * The lock is thin. We must ensure that the lock is owned
707 * by the given thread before unlocking it.
708 */
Elliott Hughesf8e01272011-10-17 11:29:05 -0700709 if (LW_LOCK_OWNER(thin) == self->GetThinLockId()) {
Elliott Hughes5f791332011-09-15 17:45:30 -0700710 /*
711 * We are the lock owner. It is safe to update the lock
712 * without CAS as lock ownership guards the lock itself.
713 */
714 if (LW_LOCK_COUNT(thin) == 0) {
715 /*
716 * The lock was not recursively acquired, the common
717 * case. Unlock by clearing all bits except for the
718 * hash state.
719 */
720 thin &= (LW_HASH_STATE_MASK << LW_HASH_STATE_SHIFT);
721 android_atomic_release_store(thin, thinp);
722 } else {
723 /*
724 * The object was recursively acquired. Decrement the
725 * lock recursion count field.
726 */
727 *thinp -= 1 << LW_LOCK_COUNT_SHIFT;
728 }
729 } else {
730 /*
731 * We do not own the lock. The JVM spec requires that we
732 * throw an exception in this case.
733 */
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800734 FailedUnlock(obj, self, NULL, NULL);
Elliott Hughes5f791332011-09-15 17:45:30 -0700735 return false;
736 }
737 } else {
738 /*
739 * The lock is fat. We must check to see if Unlock has
740 * raised any exceptions before continuing.
741 */
742 DCHECK(LW_MONITOR(*thinp) != NULL);
743 if (!LW_MONITOR(*thinp)->Unlock(self)) {
744 // An exception has been raised. Do not fall through.
745 return false;
746 }
747 }
748 return true;
749}
750
751/*
752 * Object.wait(). Also called for class init.
753 */
754void Monitor::Wait(Thread* self, Object *obj, int64_t ms, int32_t ns, bool interruptShouldThrow) {
755 volatile int32_t* thinp = obj->GetRawLockWordAddress();
756
757 // If the lock is still thin, we need to fatten it.
758 uint32_t thin = *thinp;
759 if (LW_SHAPE(thin) == LW_SHAPE_THIN) {
760 // Make sure that 'self' holds the lock.
Elliott Hughesf8e01272011-10-17 11:29:05 -0700761 if (LW_LOCK_OWNER(thin) != self->GetThinLockId()) {
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800762 ThrowIllegalMonitorStateExceptionF("object not locked by thread before wait()");
Elliott Hughes5f791332011-09-15 17:45:30 -0700763 return;
764 }
765
766 /* This thread holds the lock. We need to fatten the lock
767 * so 'self' can block on it. Don't update the object lock
768 * field yet, because 'self' needs to acquire the lock before
769 * any other thread gets a chance.
770 */
771 Inflate(self, obj);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800772 VLOG(monitor) << StringPrintf("monitor: thread %d fattened lock %p by wait()", self->GetThinLockId(), thinp);
Elliott Hughes5f791332011-09-15 17:45:30 -0700773 }
774 LW_MONITOR(*thinp)->Wait(self, ms, ns, interruptShouldThrow);
775}
776
777void Monitor::Notify(Thread* self, Object *obj) {
778 uint32_t thin = *obj->GetRawLockWordAddress();
779
780 // If the lock is still thin, there aren't any waiters;
781 // waiting on an object forces lock fattening.
782 if (LW_SHAPE(thin) == LW_SHAPE_THIN) {
783 // Make sure that 'self' holds the lock.
Elliott Hughesf8e01272011-10-17 11:29:05 -0700784 if (LW_LOCK_OWNER(thin) != self->GetThinLockId()) {
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800785 ThrowIllegalMonitorStateExceptionF("object not locked by thread before notify()");
Elliott Hughes5f791332011-09-15 17:45:30 -0700786 return;
787 }
788 // no-op; there are no waiters to notify.
789 } else {
790 // It's a fat lock.
791 LW_MONITOR(thin)->Notify(self);
792 }
793}
794
795void Monitor::NotifyAll(Thread* self, Object *obj) {
796 uint32_t thin = *obj->GetRawLockWordAddress();
797
798 // If the lock is still thin, there aren't any waiters;
799 // waiting on an object forces lock fattening.
800 if (LW_SHAPE(thin) == LW_SHAPE_THIN) {
801 // Make sure that 'self' holds the lock.
Elliott Hughesf8e01272011-10-17 11:29:05 -0700802 if (LW_LOCK_OWNER(thin) != self->GetThinLockId()) {
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800803 ThrowIllegalMonitorStateExceptionF("object not locked by thread before notifyAll()");
Elliott Hughes5f791332011-09-15 17:45:30 -0700804 return;
805 }
806 // no-op; there are no waiters to notify.
807 } else {
808 // It's a fat lock.
809 LW_MONITOR(thin)->NotifyAll(self);
810 }
811}
812
Brian Carlstrom24a3c2e2011-10-17 18:07:52 -0700813uint32_t Monitor::GetThinLockId(uint32_t raw_lock_word) {
Elliott Hughes5f791332011-09-15 17:45:30 -0700814 if (LW_SHAPE(raw_lock_word) == LW_SHAPE_THIN) {
815 return LW_LOCK_OWNER(raw_lock_word);
816 } else {
817 Thread* owner = LW_MONITOR(raw_lock_word)->owner_;
818 return owner ? owner->GetThinLockId() : 0;
819 }
820}
821
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700822void Monitor::DescribeWait(std::ostream& os, const Thread* thread) {
823 Thread::State state = thread->GetState();
824
825 Object* object = NULL;
826 uint32_t lock_owner = ThreadList::kInvalidId;
827 if (state == Thread::kWaiting || state == Thread::kTimedWaiting) {
828 os << " - waiting on ";
829 Monitor* monitor = thread->wait_monitor_;
830 if (monitor != NULL) {
831 object = monitor->obj_;
832 }
833 lock_owner = Thread::LockOwnerFromThreadLock(object);
834 } else if (state == Thread::kBlocked) {
835 os << " - waiting to lock ";
836 object = thread->monitor_enter_object_;
837 if (object != NULL) {
Brian Carlstrom24a3c2e2011-10-17 18:07:52 -0700838 lock_owner = object->GetThinLockId();
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700839 }
840 } else {
841 // We're not waiting on anything.
842 return;
843 }
844 os << "<" << object << ">";
845
846 // - waiting on <0x613f83d8> (a java.lang.ThreadLock) held by thread 5
847 // - waiting on <0x6008c468> (a java.lang.Class<java.lang.ref.ReferenceQueue>)
848 os << " (a " << PrettyTypeOf(object) << ")";
849
850 if (lock_owner != ThreadList::kInvalidId) {
851 os << " held by thread " << lock_owner;
852 }
853
854 os << "\n";
855}
856
jeffhao33dc7712011-11-09 17:54:24 -0800857void Monitor::TranslateLocation(const Method* method, uint32_t pc,
858 const char*& source_file, uint32_t& line_number) const {
859 // If method is null, location is unknown
860 if (method == NULL) {
Elliott Hughes12c51e32012-01-17 20:25:05 -0800861 source_file = "";
jeffhao33dc7712011-11-09 17:54:24 -0800862 line_number = 0;
863 return;
864 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800865 MethodHelper mh(method);
866 source_file = mh.GetDeclaringClassSourceFile();
Elliott Hughes12c51e32012-01-17 20:25:05 -0800867 if (source_file == NULL) {
868 source_file = "";
869 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800870 line_number = mh.GetLineNumFromNativePC(pc);
jeffhao33dc7712011-11-09 17:54:24 -0800871}
872
Elliott Hughesc33a32b2011-10-11 18:18:07 -0700873MonitorList::MonitorList() : lock_("MonitorList lock") {
874}
875
876MonitorList::~MonitorList() {
877 MutexLock mu(lock_);
878 STLDeleteElements(&list_);
879}
880
881void MonitorList::Add(Monitor* m) {
882 MutexLock mu(lock_);
883 list_.push_front(m);
884}
885
886void MonitorList::SweepMonitorList(Heap::IsMarkedTester is_marked, void* arg) {
887 MutexLock mu(lock_);
888 typedef std::list<Monitor*>::iterator It; // TODO: C++0x auto
889 It it = list_.begin();
890 while (it != list_.end()) {
891 Monitor* m = *it;
892 if (!is_marked(m->GetObject(), arg)) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800893 VLOG(monitor) << "freeing monitor " << m << " belonging to unmarked object " << m->GetObject();
Elliott Hughesc33a32b2011-10-11 18:18:07 -0700894 delete m;
895 it = list_.erase(it);
896 } else {
897 ++it;
898 }
899 }
900}
901
Elliott Hughes5f791332011-09-15 17:45:30 -0700902} // namespace art