diff options
Diffstat (limited to 'runtime/monitor.cc')
-rw-r--r-- | runtime/monitor.cc | 93 |
1 files changed, 47 insertions, 46 deletions
diff --git a/runtime/monitor.cc b/runtime/monitor.cc index 1a80ded..4b41225 100644 --- a/runtime/monitor.cc +++ b/runtime/monitor.cc @@ -68,11 +68,11 @@ static constexpr uint64_t kLongWaitMs = 100; * at any given time. */ -bool (*Monitor::is_sensitive_thread_hook_)() = NULL; +bool (*Monitor::is_sensitive_thread_hook_)() = nullptr; uint32_t Monitor::lock_profiling_threshold_ = 0; bool Monitor::IsSensitiveThread() { - if (is_sensitive_thread_hook_ != NULL) { + if (is_sensitive_thread_hook_ != nullptr) { return (*is_sensitive_thread_hook_)(); } return false; @@ -90,9 +90,9 @@ Monitor::Monitor(Thread* self, Thread* owner, mirror::Object* obj, int32_t hash_ owner_(owner), lock_count_(0), obj_(GcRoot<mirror::Object>(obj)), - wait_set_(NULL), + wait_set_(nullptr), hash_code_(hash_code), - locking_method_(NULL), + locking_method_(nullptr), locking_dex_pc_(0), monitor_id_(MonitorPool::ComputeMonitorId(this, self)) { #ifdef __LP64__ @@ -113,9 +113,9 @@ Monitor::Monitor(Thread* self, Thread* owner, mirror::Object* obj, int32_t hash_ owner_(owner), lock_count_(0), obj_(GcRoot<mirror::Object>(obj)), - wait_set_(NULL), + wait_set_(nullptr), hash_code_(hash_code), - locking_method_(NULL), + locking_method_(nullptr), locking_dex_pc_(0), monitor_id_(id) { #ifdef __LP64__ @@ -183,9 +183,9 @@ Monitor::~Monitor() { void Monitor::AppendToWaitSet(Thread* thread) { DCHECK(owner_ == Thread::Current()); - DCHECK(thread != NULL); + DCHECK(thread != nullptr); DCHECK(thread->GetWaitNext() == nullptr) << thread->GetWaitNext(); - if (wait_set_ == NULL) { + if (wait_set_ == nullptr) { wait_set_ = thread; return; } @@ -200,8 +200,8 @@ void Monitor::AppendToWaitSet(Thread* thread) { void Monitor::RemoveFromWaitSet(Thread *thread) { DCHECK(owner_ == Thread::Current()); - DCHECK(thread != NULL); - if (wait_set_ == NULL) { + DCHECK(thread != nullptr); + if (wait_set_ == nullptr) { return; } if (wait_set_ == thread) { @@ -211,7 +211,7 @@ void Monitor::RemoveFromWaitSet(Thread *thread) { } Thread* t = wait_set_; - while (t->GetWaitNext() != NULL) { + while (t->GetWaitNext() != nullptr) { if (t->GetWaitNext() == thread) { t->SetWaitNext(thread->GetWaitNext()); thread->SetWaitNext(nullptr); @@ -253,7 +253,8 @@ void Monitor::Lock(Thread* self) { self->SetMonitorEnterObject(GetObject()); { ScopedThreadStateChange tsc(self, kBlocked); // Change to blocked and give up mutator_lock_. - MutexLock mu2(self, monitor_lock_); // Reacquire monitor_lock_ without mutator_lock_ for Wait. + // Reacquire monitor_lock_ without mutator_lock_ for Wait. + MutexLock mu2(self, monitor_lock_); if (owner_ != nullptr) { // Did the owner_ give the lock up? if (ATRACE_ENABLED()) { std::string name; @@ -311,8 +312,8 @@ static void ThrowIllegalMonitorStateExceptionF(const char* fmt, ...) } static std::string ThreadToString(Thread* thread) { - if (thread == NULL) { - return "NULL"; + if (thread == nullptr) { + return "nullptr"; } std::ostringstream oss; // TODO: alternatively, we could just return the thread's name. @@ -322,7 +323,7 @@ static std::string ThreadToString(Thread* thread) { void Monitor::FailedUnlock(mirror::Object* o, Thread* expected_owner, Thread* found_owner, Monitor* monitor) { - Thread* current_owner = NULL; + Thread* current_owner = nullptr; std::string current_owner_string; std::string expected_owner_string; std::string found_owner_string; @@ -331,14 +332,14 @@ void Monitor::FailedUnlock(mirror::Object* o, Thread* expected_owner, Thread* fo // Acquire thread list lock so threads won't disappear from under us. MutexLock mu(Thread::Current(), *Locks::thread_list_lock_); // Re-read owner now that we hold lock. - current_owner = (monitor != NULL) ? monitor->GetOwner() : NULL; + current_owner = (monitor != nullptr) ? monitor->GetOwner() : nullptr; // Get short descriptions of the threads involved. current_owner_string = ThreadToString(current_owner); expected_owner_string = ThreadToString(expected_owner); found_owner_string = ThreadToString(found_owner); } - if (current_owner == NULL) { - if (found_owner == NULL) { + if (current_owner == nullptr) { + if (found_owner == nullptr) { ThrowIllegalMonitorStateExceptionF("unlock of unowned monitor on object of type '%s'" " on thread '%s'", PrettyTypeOf(o).c_str(), @@ -352,7 +353,7 @@ void Monitor::FailedUnlock(mirror::Object* o, Thread* expected_owner, Thread* fo expected_owner_string.c_str()); } } else { - if (found_owner == NULL) { + if (found_owner == nullptr) { // Race: originally there was no owner, there is now ThrowIllegalMonitorStateExceptionF("unlock of monitor owned by '%s' on object of type '%s'" " (originally believed to be unowned) on thread '%s'", @@ -380,14 +381,14 @@ void Monitor::FailedUnlock(mirror::Object* o, Thread* expected_owner, Thread* fo } bool Monitor::Unlock(Thread* self) { - DCHECK(self != NULL); + DCHECK(self != nullptr); MutexLock mu(self, monitor_lock_); Thread* owner = owner_; if (owner == self) { // We own the monitor, so nobody else can be in here. if (lock_count_ == 0) { - owner_ = NULL; - locking_method_ = NULL; + owner_ = nullptr; + locking_method_ = nullptr; locking_dex_pc_ = 0; // Wake a contender. monitor_contenders_.Signal(self); @@ -406,7 +407,7 @@ bool Monitor::Unlock(Thread* self) { void Monitor::Wait(Thread* self, int64_t ms, int32_t ns, bool interruptShouldThrow, ThreadState why) { - DCHECK(self != NULL); + DCHECK(self != nullptr); DCHECK(why == kTimedWaiting || why == kWaiting || why == kSleeping); monitor_lock_.Lock(self); @@ -446,9 +447,9 @@ void Monitor::Wait(Thread* self, int64_t ms, int32_t ns, ++num_waiters_; int prev_lock_count = lock_count_; lock_count_ = 0; - owner_ = NULL; + owner_ = nullptr; mirror::ArtMethod* saved_method = locking_method_; - locking_method_ = NULL; + locking_method_ = nullptr; uintptr_t saved_dex_pc = locking_dex_pc_; locking_dex_pc_ = 0; @@ -465,7 +466,7 @@ void Monitor::Wait(Thread* self, int64_t ms, int32_t ns, MutexLock mu(self, *self->GetWaitMutex()); // Set wait_monitor_ to the monitor object we will be waiting on. When wait_monitor_ is - // non-NULL a notifying or interrupting thread must signal the thread's wait_cond_ to wake it + // non-null a notifying or interrupting thread must signal the thread's wait_cond_ to wake it // up. DCHECK(self->GetWaitMonitor() == nullptr); self->SetWaitMonitor(this); @@ -538,13 +539,13 @@ void Monitor::Wait(Thread* self, int64_t ms, int32_t ns, self->SetInterruptedLocked(false); } if (interruptShouldThrow) { - self->ThrowNewException("Ljava/lang/InterruptedException;", NULL); + self->ThrowNewException("Ljava/lang/InterruptedException;", nullptr); } } } void Monitor::Notify(Thread* self) { - DCHECK(self != NULL); + DCHECK(self != nullptr); MutexLock mu(self, monitor_lock_); // Make sure that we hold the lock. if (owner_ != self) { @@ -552,7 +553,7 @@ void Monitor::Notify(Thread* self) { return; } // Signal the first waiting thread in the wait set. - while (wait_set_ != NULL) { + while (wait_set_ != nullptr) { Thread* thread = wait_set_; wait_set_ = thread->GetWaitNext(); thread->SetWaitNext(nullptr); @@ -567,7 +568,7 @@ void Monitor::Notify(Thread* self) { } void Monitor::NotifyAll(Thread* self) { - DCHECK(self != NULL); + DCHECK(self != nullptr); MutexLock mu(self, monitor_lock_); // Make sure that we hold the lock. if (owner_ != self) { @@ -575,7 +576,7 @@ void Monitor::NotifyAll(Thread* self) { return; } // Signal all threads in the wait set. - while (wait_set_ != NULL) { + while (wait_set_ != nullptr) { Thread* thread = wait_set_; wait_set_ = thread->GetWaitNext(); thread->SetWaitNext(nullptr); @@ -625,7 +626,7 @@ bool Monitor::Deflate(Thread* self, mirror::Object* obj) { obj->SetLockWord(new_lw, false); VLOG(monitor) << "Deflated" << obj << " to empty lock word"; } - // The monitor is deflated, mark the object as nullptr so that we know to delete it during the + // The monitor is deflated, mark the object as null so that we know to delete it during the // next GC. monitor->obj_ = GcRoot<mirror::Object>(nullptr); } @@ -697,8 +698,8 @@ static mirror::Object* FakeUnlock(mirror::Object* obj) } mirror::Object* Monitor::MonitorEnter(Thread* self, mirror::Object* obj) { - DCHECK(self != NULL); - DCHECK(obj != NULL); + DCHECK(self != nullptr); + DCHECK(obj != nullptr); obj = FakeLock(obj); uint32_t thread_id = self->GetThreadId(); size_t contention_count = 0; @@ -772,8 +773,8 @@ mirror::Object* Monitor::MonitorEnter(Thread* self, mirror::Object* obj) { } bool Monitor::MonitorExit(Thread* self, mirror::Object* obj) { - DCHECK(self != NULL); - DCHECK(obj != NULL); + DCHECK(self != nullptr); + DCHECK(obj != nullptr); obj = FakeUnlock(obj); StackHandleScope<1> hs(self); Handle<mirror::Object> h_obj(hs.NewHandle(obj)); @@ -979,11 +980,11 @@ mirror::Object* Monitor::GetContendedMonitor(Thread* thread) { // This is used to implement JDWP's ThreadReference.CurrentContendedMonitor, and has a bizarre // definition of contended that includes a monitor a thread is trying to enter... mirror::Object* result = thread->GetMonitorEnterObject(); - if (result == NULL) { + if (result == nullptr) { // ...but also a monitor that the thread is waiting on. MutexLock mu(Thread::Current(), *thread->GetWaitMutex()); Monitor* monitor = thread->GetWaitMonitor(); - if (monitor != NULL) { + if (monitor != nullptr) { result = monitor->GetObject(); } } @@ -993,7 +994,7 @@ mirror::Object* Monitor::GetContendedMonitor(Thread* thread) { void Monitor::VisitLocks(StackVisitor* stack_visitor, void (*callback)(mirror::Object*, void*), void* callback_context, bool abort_on_failure) { mirror::ArtMethod* m = stack_visitor->GetMethod(); - CHECK(m != NULL); + CHECK(m != nullptr); // Native methods are an easy special case. // TODO: use the JNI implementation's table of explicit MonitorEnter calls and dump those too. @@ -1013,7 +1014,7 @@ void Monitor::VisitLocks(StackVisitor* stack_visitor, void (*callback)(mirror::O // Is there any reason to believe there's any synchronization in this method? const DexFile::CodeItem* code_item = m->GetCodeItem(); - CHECK(code_item != NULL) << PrettyMethod(m); + CHECK(code_item != nullptr) << PrettyMethod(m); if (code_item->tries_size_ == 0) { return; // No "tries" implies no synchronization, so no held locks to report. } @@ -1088,13 +1089,13 @@ bool Monitor::IsLocked() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { void Monitor::TranslateLocation(mirror::ArtMethod* method, uint32_t dex_pc, const char** source_file, uint32_t* line_number) const { // If method is null, location is unknown - if (method == NULL) { + if (method == nullptr) { *source_file = ""; *line_number = 0; return; } *source_file = method->GetDeclaringClassSourceFile(); - if (*source_file == NULL) { + if (*source_file == nullptr) { *source_file = ""; } *line_number = method->GetLineNumFromDexPC(dex_pc); @@ -1103,7 +1104,7 @@ void Monitor::TranslateLocation(mirror::ArtMethod* method, uint32_t dex_pc, uint32_t Monitor::GetOwnerThreadId() { MutexLock mu(Thread::Current(), monitor_lock_); Thread* owner = owner_; - if (owner != NULL) { + if (owner != nullptr) { return owner->GetThreadId(); } else { return ThreadList::kInvalidThreadId; @@ -1185,7 +1186,7 @@ static mirror::Object* MonitorDeflateCallback(mirror::Object* object, void* arg) if (Monitor::Deflate(args->self, object)) { DCHECK_NE(object->GetLockWord(true).GetState(), LockWord::kFatLocked); ++args->deflate_count; - // If we deflated, return nullptr so that the monitor gets removed from the array. + // If we deflated, return null so that the monitor gets removed from the array. return nullptr; } return object; // Monitor was not deflated. @@ -1198,7 +1199,7 @@ size_t MonitorList::DeflateMonitors() { return args.deflate_count; } -MonitorInfo::MonitorInfo(mirror::Object* obj) : owner_(NULL), entry_count_(0) { +MonitorInfo::MonitorInfo(mirror::Object* obj) : owner_(nullptr), entry_count_(0) { DCHECK(obj != nullptr); LockWord lock_word = obj->GetLockWord(true); switch (lock_word.GetState()) { @@ -1217,7 +1218,7 @@ MonitorInfo::MonitorInfo(mirror::Object* obj) : owner_(NULL), entry_count_(0) { Monitor* mon = lock_word.FatLockMonitor(); owner_ = mon->owner_; entry_count_ = 1 + mon->lock_count_; - for (Thread* waiter = mon->wait_set_; waiter != NULL; waiter = waiter->GetWaitNext()) { + for (Thread* waiter = mon->wait_set_; waiter != nullptr; waiter = waiter->GetWaitNext()) { waiters_.push_back(waiter); } break; |