runtime/gc/reference_processor.cc - LeafOS-Project/android_art - Gitiles

 /*
  * Copyright (C) 2014 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include "reference_processor.h"

 #include "art_field-inl.h"
 #include "base/mutex.h"
 #include "base/time_utils.h"
 #include "base/utils.h"
 #include "base/systrace.h"
 #include "class_root-inl.h"
 #include "collector/garbage_collector.h"
 #include "jni/java_vm_ext.h"
 #include "mirror/class-inl.h"
 #include "mirror/object-inl.h"
 #include "mirror/reference-inl.h"
 #include "nativehelper/scoped_local_ref.h"
 #include "object_callbacks.h"
 #include "reflection.h"
 #include "scoped_thread_state_change-inl.h"
 #include "task_processor.h"
 #include "thread-inl.h"
 #include "thread_pool.h"
 #include "well_known_classes.h"

 namespace art {
 namespace gc {

 static constexpr bool kAsyncReferenceQueueAdd = false;

 ReferenceProcessor::ReferenceProcessor()
     : collector_(nullptr),
       condition_("reference processor condition", *Locks::reference_processor_lock_) ,
       soft_reference_queue_(Locks::reference_queue_soft_references_lock_),
       weak_reference_queue_(Locks::reference_queue_weak_references_lock_),
       finalizer_reference_queue_(Locks::reference_queue_finalizer_references_lock_),
       phantom_reference_queue_(Locks::reference_queue_phantom_references_lock_),
       cleared_references_(Locks::reference_queue_cleared_references_lock_) {
 }

 static inline MemberOffset GetSlowPathFlagOffset(ObjPtr<mirror::Class> reference_class)
     REQUIRES_SHARED(Locks::mutator_lock_) {
   DCHECK(reference_class == GetClassRoot<mirror::Reference>());
   // Second static field
   ArtField* field = reference_class->GetStaticField(1);
   DCHECK_STREQ(field->GetName(), "slowPathEnabled");
   return field->GetOffset();
 }

 static inline void SetSlowPathFlag(bool enabled) REQUIRES_SHARED(Locks::mutator_lock_) {
   ObjPtr<mirror::Class> reference_class = GetClassRoot<mirror::Reference>();
   MemberOffset slow_path_offset = GetSlowPathFlagOffset(reference_class);
   reference_class->SetFieldBoolean</* kTransactionActive= */ false, /* kCheckTransaction= */ false>(
       slow_path_offset, enabled ? 1 : 0);
 }

 void ReferenceProcessor::EnableSlowPath() {
   SetSlowPathFlag(/* enabled= */ true);
 }

 void ReferenceProcessor::DisableSlowPath(Thread* self) {
   SetSlowPathFlag(/* enabled= */ false);
   condition_.Broadcast(self);
 }

 bool ReferenceProcessor::SlowPathEnabled() {
   ObjPtr<mirror::Class> reference_class = GetClassRoot<mirror::Reference>();
   MemberOffset slow_path_offset = GetSlowPathFlagOffset(reference_class);
   return reference_class->GetFieldBoolean(slow_path_offset);
 }

 void ReferenceProcessor::BroadcastForSlowPath(Thread* self) {
   MutexLock mu(self, *Locks::reference_processor_lock_);
   condition_.Broadcast(self);
 }

 ObjPtr<mirror::Object> ReferenceProcessor::GetReferent(Thread* self,
                                                        ObjPtr<mirror::Reference> reference) {
   auto slow_path_required = [this, self]() REQUIRES_SHARED(Locks::mutator_lock_) {
     return gUseReadBarrier ? !self->GetWeakRefAccessEnabled() : SlowPathEnabled();
   };
   if (!slow_path_required()) {
     return reference->GetReferent();
   }
   // If the referent is null then it is already cleared, we can just return null since there is no
   // scenario where it becomes non-null during the reference processing phase.
   // A read barrier may be unsafe here, and we use the result only when it's null or marked.
   ObjPtr<mirror::Object> referent = reference->template GetReferent<kWithoutReadBarrier>();
   if (referent.IsNull()) {
     return referent;
   }

   bool started_trace = false;
   uint64_t start_millis;
   auto finish_trace = [](uint64_t start_millis) {
     ATraceEnd();
     uint64_t millis = MilliTime() - start_millis;
     static constexpr uint64_t kReportMillis = 10;  // Long enough to risk dropped frames.
     if (millis > kReportMillis) {
       LOG(WARNING) << "Weak pointer dereference blocked for " << millis << " milliseconds.";
     }
   };

   MutexLock mu(self, *Locks::reference_processor_lock_);
   // Keeping reference_processor_lock_ blocks the broadcast when we try to reenable the fast path.
   while (slow_path_required()) {
     DCHECK(collector_ != nullptr);
     const bool other_read_barrier = !kUseBakerReadBarrier && gUseReadBarrier;
     if (UNLIKELY(reference->IsFinalizerReferenceInstance()
                  || rp_state_ == RpState::kStarting /* too early to determine mark state */
                  || (other_read_barrier && reference->IsPhantomReferenceInstance()))) {
       // Odd cases in which it doesn't hurt to just wait, or the wait is likely to be very brief.

       // Check and run the empty checkpoint before blocking so the empty checkpoint will work in the
       // presence of threads blocking for weak ref access.
       self->CheckEmptyCheckpointFromWeakRefAccess(Locks::reference_processor_lock_);
       if (!started_trace) {
         ATraceBegin("GetReferent blocked");
         started_trace = true;
         start_millis = MilliTime();
       }
       condition_.WaitHoldingLocks(self);
       continue;
     }
     DCHECK(!reference->IsPhantomReferenceInstance());

     if (rp_state_ == RpState::kInitClearingDone) {
       // Reachable references have their final referent values.
       break;
     }
     // Although reference processing is not done, we can always predict the correct return value
     // based on the current mark state. No additional marking from finalizers has been done, since
     // we hold reference_processor_lock_, which is required to advance to kInitClearingDone.
     DCHECK(rp_state_ == RpState::kInitMarkingDone);
     // Re-load and re-check referent, since the current one may have been read before we acquired
     // reference_lock. In particular a Reference.clear() call may have intervened. (b/33569625)
     referent = reference->GetReferent<kWithoutReadBarrier>();
     ObjPtr<mirror::Object> forwarded_ref =
         referent.IsNull() ? nullptr : collector_->IsMarked(referent.Ptr());
     // Either the referent was marked, and forwarded_ref is the correct return value, or it
     // was not, and forwarded_ref == null, which is again the correct return value.
     if (started_trace) {
       finish_trace(start_millis);
     }
     return forwarded_ref;
   }
   if (started_trace) {
     finish_trace(start_millis);
   }
   return reference->GetReferent();
 }

 // Forward SoftReferences. Can be done before we disable Reference access. Only
 // invoked if we are not clearing SoftReferences.
 uint32_t ReferenceProcessor::ForwardSoftReferences(TimingLogger* timings) {
   TimingLogger::ScopedTiming split(
       concurrent_ ? "ForwardSoftReferences" : "(Paused)ForwardSoftReferences", timings);
   // We used to argue that we should be smarter about doing this conditionally, but it's unclear
   // that's actually better than the more predictable strategy of basically only clearing
   // SoftReferences just before we would otherwise run out of memory.
   uint32_t non_null_refs = soft_reference_queue_.ForwardSoftReferences(collector_);
   if (ATraceEnabled()) {
     static constexpr size_t kBufSize = 80;
     char buf[kBufSize];
     snprintf(buf, kBufSize, "Marking for %" PRIu32 " SoftReferences", non_null_refs);
     ATraceBegin(buf);
     collector_->ProcessMarkStack();
     ATraceEnd();
   } else {
     collector_->ProcessMarkStack();
   }
   return non_null_refs;
 }

 void ReferenceProcessor::Setup(Thread* self,
                                collector::GarbageCollector* collector,
                                bool concurrent,
                                bool clear_soft_references) {
   DCHECK(collector != nullptr);
   MutexLock mu(self, *Locks::reference_processor_lock_);
   collector_ = collector;
   rp_state_ = RpState::kStarting;
   concurrent_ = concurrent;
   clear_soft_references_ = clear_soft_references;
 }

 // Process reference class instances and schedule finalizations.
 // We advance rp_state_ to signal partial completion for the benefit of GetReferent.
 void ReferenceProcessor::ProcessReferences(Thread* self, TimingLogger* timings) {
   TimingLogger::ScopedTiming t(concurrent_ ? __FUNCTION__ : "(Paused)ProcessReferences", timings);
   if (!clear_soft_references_) {
     // Forward any additional SoftReferences we discovered late, now that reference access has been
     // inhibited.
     while (!soft_reference_queue_.IsEmpty()) {
       ForwardSoftReferences(timings);
     }
   }
   {
     MutexLock mu(self, *Locks::reference_processor_lock_);
     if (!gUseReadBarrier) {
       CHECK_EQ(SlowPathEnabled(), concurrent_) << "Slow path must be enabled iff concurrent";
     } else {
       // Weak ref access is enabled at Zygote compaction by SemiSpace (concurrent_ == false).
       CHECK_EQ(!self->GetWeakRefAccessEnabled(), concurrent_);
     }
     DCHECK(rp_state_ == RpState::kStarting);
     rp_state_ = RpState::kInitMarkingDone;
     condition_.Broadcast(self);
   }
   if (kIsDebugBuild && collector_->IsTransactionActive()) {
     // In transaction mode, we shouldn't enqueue any Reference to the queues.
     // See DelayReferenceReferent().
     DCHECK(soft_reference_queue_.IsEmpty());
     DCHECK(weak_reference_queue_.IsEmpty());
     DCHECK(finalizer_reference_queue_.IsEmpty());
     DCHECK(phantom_reference_queue_.IsEmpty());
   }
   // Clear all remaining soft and weak references with white referents.
   // This misses references only reachable through finalizers.
   soft_reference_queue_.ClearWhiteReferences(&cleared_references_, collector_);
   weak_reference_queue_.ClearWhiteReferences(&cleared_references_, collector_);
   // Defer PhantomReference processing until we've finished marking through finalizers.
   {
     // TODO: Capture mark state of some system weaks here. If the referent was marked here,
     // then it is now safe to return, since it can only refer to marked objects. If it becomes
     // marked below, that is no longer guaranteed.
     MutexLock mu(self, *Locks::reference_processor_lock_);
     rp_state_ = RpState::kInitClearingDone;
     // At this point, all mutator-accessible data is marked (black). Objects enqueued for
     // finalization will only be made available to the mutator via CollectClearedReferences after
     // we're fully done marking. Soft and WeakReferences accessible to the mutator have been
     // processed and refer only to black objects.  Thus there is no danger of the mutator getting
     // access to non-black objects.  Weak reference processing is still nominally suspended,
     // But many kinds of references, including all java.lang.ref ones, are handled normally from
     // here on. See GetReferent().
   }
   {
     TimingLogger::ScopedTiming t2(
         concurrent_ ? "EnqueueFinalizerReferences" : "(Paused)EnqueueFinalizerReferences", timings);
     // Preserve all white objects with finalize methods and schedule them for finalization.
     FinalizerStats finalizer_stats =
         finalizer_reference_queue_.EnqueueFinalizerReferences(&cleared_references_, collector_);
     if (ATraceEnabled()) {
       static constexpr size_t kBufSize = 80;
       char buf[kBufSize];
       snprintf(buf, kBufSize, "Marking from %" PRIu32 " / %" PRIu32 " finalizers",
                finalizer_stats.num_enqueued_, finalizer_stats.num_refs_);
       ATraceBegin(buf);
       collector_->ProcessMarkStack();
       ATraceEnd();
     } else {
       collector_->ProcessMarkStack();
     }
   }

   // Process all soft and weak references with white referents, where the references are reachable
   // only from finalizers. It is unclear that there is any way to do this without slightly
   // violating some language spec. We choose to apply normal Reference processing rules for these.
   // This exposes the following issues:
   // 1) In the case of an unmarked referent, we may end up enqueuing an "unreachable" reference.
   //    This appears unavoidable, since we need to clear the reference for safety, unless we
   //    mark the referent and undo finalization decisions for objects we encounter during marking.
   //    (Some versions of the RI seem to do something along these lines.)
   //    Or we could clear the reference without enqueuing it, which also seems strange and
   //    unhelpful.
   // 2) In the case of a marked referent, we will preserve a reference to objects that may have
   //    been enqueued for finalization. Again fixing this would seem to involve at least undoing
   //    previous finalization / reference clearing decisions. (This would also mean than an object
   //    containing both a strong and a WeakReference to the same referent could see the
   //    WeakReference cleared.)
   // The treatment in (2) is potentially quite dangerous, since Reference.get() can e.g. return a
   // finalized object containing pointers to native objects that have already been deallocated.
   // But it can be argued that this is just an instance of the broader rule that it is not safe
   // for finalizers to access otherwise inaccessible finalizable objects.
   soft_reference_queue_.ClearWhiteReferences(&cleared_references_, collector_,
                                              /*report_cleared=*/ true);
   weak_reference_queue_.ClearWhiteReferences(&cleared_references_, collector_,
                                              /*report_cleared=*/ true);

   // Clear all phantom references with white referents. It's fine to do this just once here.
   phantom_reference_queue_.ClearWhiteReferences(&cleared_references_, collector_);

   // At this point all reference queues other than the cleared references should be empty.
   DCHECK(soft_reference_queue_.IsEmpty());
   DCHECK(weak_reference_queue_.IsEmpty());
   DCHECK(finalizer_reference_queue_.IsEmpty());
   DCHECK(phantom_reference_queue_.IsEmpty());

   {
     MutexLock mu(self, *Locks::reference_processor_lock_);
     // Need to always do this since the next GC may be concurrent. Doing this for only concurrent
     // could result in a stale is_marked_callback_ being called before the reference processing
     // starts since there is a small window of time where slow_path_enabled_ is enabled but the
     // callback isn't yet set.
     if (!gUseReadBarrier && concurrent_) {
       // Done processing, disable the slow path and broadcast to the waiters.
       DisableSlowPath(self);
     }
   }
 }

 // Process the "referent" field in a java.lang.ref.Reference.  If the referent has not yet been
 // marked, put it on the appropriate list in the heap for later processing.
 void ReferenceProcessor::DelayReferenceReferent(ObjPtr<mirror::Class> klass,
                                                 ObjPtr<mirror::Reference> ref,
                                                 collector::GarbageCollector* collector) {
   // klass can be the class of the old object if the visitor already updated the class of ref.
   DCHECK(klass != nullptr);
   DCHECK(klass->IsTypeOfReferenceClass());
   mirror::HeapReference<mirror::Object>* referent = ref->GetReferentReferenceAddr();
   // do_atomic_update needs to be true because this happens outside of the reference processing
   // phase.
   if (!collector->IsNullOrMarkedHeapReference(referent, /*do_atomic_update=*/true)) {
     if (UNLIKELY(collector->IsTransactionActive())) {
       // In transaction mode, keep the referent alive and avoid any reference processing to avoid the
       // issue of rolling back reference processing.  do_atomic_update needs to be true because this
       // happens outside of the reference processing phase.
       if (!referent->IsNull()) {
         collector->MarkHeapReference(referent, /*do_atomic_update=*/ true);
       }
       return;
     }
     Thread* self = Thread::Current();
     // TODO: Remove these locks, and use atomic stacks for storing references?
     // We need to check that the references haven't already been enqueued since we can end up
     // scanning the same reference multiple times due to dirty cards.
     if (klass->IsSoftReferenceClass()) {
       soft_reference_queue_.AtomicEnqueueIfNotEnqueued(self, ref);
     } else if (klass->IsWeakReferenceClass()) {
       weak_reference_queue_.AtomicEnqueueIfNotEnqueued(self, ref);
     } else if (klass->IsFinalizerReferenceClass()) {
       finalizer_reference_queue_.AtomicEnqueueIfNotEnqueued(self, ref);
     } else if (klass->IsPhantomReferenceClass()) {
       phantom_reference_queue_.AtomicEnqueueIfNotEnqueued(self, ref);
     } else {
       LOG(FATAL) << "Invalid reference type " << klass->PrettyClass() << " " << std::hex
                  << klass->GetAccessFlags();
     }
   }
 }

 void ReferenceProcessor::UpdateRoots(IsMarkedVisitor* visitor) {
   cleared_references_.UpdateRoots(visitor);
 }

 class ClearedReferenceTask : public HeapTask {
  public:
   explicit ClearedReferenceTask(jobject cleared_references)
       : HeapTask(NanoTime()), cleared_references_(cleared_references) {
   }
   void Run(Thread* thread) override {
     ScopedObjectAccess soa(thread);
     WellKnownClasses::java_lang_ref_ReferenceQueue_add->InvokeStatic<'V', 'L'>(
         thread, soa.Decode<mirror::Object>(cleared_references_));
     soa.Env()->DeleteGlobalRef(cleared_references_);
   }

  private:
   const jobject cleared_references_;
 };

 SelfDeletingTask* ReferenceProcessor::CollectClearedReferences(Thread* self) {
   Locks::mutator_lock_->AssertNotHeld(self);
   // By default we don't actually need to do anything. Just return this no-op task to avoid having
   // to put in ifs.
   std::unique_ptr<SelfDeletingTask> result(new FunctionTask([](Thread*) {}));
   // When a runtime isn't started there are no reference queues to care about so ignore.
   if (!cleared_references_.IsEmpty()) {
     if (LIKELY(Runtime::Current()->IsStarted())) {
       jobject cleared_references;
       {
         ReaderMutexLock mu(self, *Locks::mutator_lock_);
         cleared_references = self->GetJniEnv()->GetVm()->AddGlobalRef(
             self, cleared_references_.GetList());
       }
       if (kAsyncReferenceQueueAdd) {
         // TODO: This can cause RunFinalization to terminate before newly freed objects are
         // finalized since they may not be enqueued by the time RunFinalization starts.
         Runtime::Current()->GetHeap()->GetTaskProcessor()->AddTask(
             self, new ClearedReferenceTask(cleared_references));
       } else {
         result.reset(new ClearedReferenceTask(cleared_references));
       }
     }
     cleared_references_.Clear();
   }
   return result.release();
 }

 void ReferenceProcessor::ClearReferent(ObjPtr<mirror::Reference> ref) {
   Thread* self = Thread::Current();
   MutexLock mu(self, *Locks::reference_processor_lock_);
   // Need to wait until reference processing is done since IsMarkedHeapReference does not have a
   // CAS. If we do not wait, it can result in the GC un-clearing references due to race conditions.
   // This also handles the race where the referent gets cleared after a null check but before
   // IsMarkedHeapReference is called.
   WaitUntilDoneProcessingReferences(self);
   if (Runtime::Current()->IsActiveTransaction()) {
     ref->ClearReferent<true>();
   } else {
     ref->ClearReferent<false>();
   }
 }

 void ReferenceProcessor::WaitUntilDoneProcessingReferences(Thread* self) {
   // Wait until we are done processing reference.
   while ((!gUseReadBarrier && SlowPathEnabled()) ||
          (gUseReadBarrier && !self->GetWeakRefAccessEnabled())) {
     // Check and run the empty checkpoint before blocking so the empty checkpoint will work in the
     // presence of threads blocking for weak ref access.
     self->CheckEmptyCheckpointFromWeakRefAccess(Locks::reference_processor_lock_);
     condition_.WaitHoldingLocks(self);
   }
 }

 bool ReferenceProcessor::MakeCircularListIfUnenqueued(
     ObjPtr<mirror::FinalizerReference> reference) {
   Thread* self = Thread::Current();
   MutexLock mu(self, *Locks::reference_processor_lock_);
   WaitUntilDoneProcessingReferences(self);
   // At this point, since the sentinel of the reference is live, it is guaranteed to not be
   // enqueued if we just finished processing references. Otherwise, we may be doing the main GC
   // phase. Since we are holding the reference processor lock, it guarantees that reference
   // processing can't begin. The GC could have just enqueued the reference one one of the internal
   // GC queues, but since we hold the lock finalizer_reference_queue_ lock it also prevents this
   // race.
   MutexLock mu2(self, *Locks::reference_queue_finalizer_references_lock_);
   if (reference->IsUnprocessed()) {
     CHECK(reference->IsFinalizerReferenceInstance());
     reference->SetPendingNext(reference);
     return true;
   }
   return false;
 }

 }  // namespace gc
 }  // namespace art
	/*
	* Copyright (C) 2014 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "reference_processor.h"

	#include "art_field-inl.h"
	#include "base/mutex.h"
	#include "base/time_utils.h"
	#include "base/utils.h"
	#include "base/systrace.h"
	#include "class_root-inl.h"
	#include "collector/garbage_collector.h"
	#include "jni/java_vm_ext.h"
	#include "mirror/class-inl.h"
	#include "mirror/object-inl.h"
	#include "mirror/reference-inl.h"
	#include "nativehelper/scoped_local_ref.h"
	#include "object_callbacks.h"
	#include "reflection.h"
	#include "scoped_thread_state_change-inl.h"
	#include "task_processor.h"
	#include "thread-inl.h"
	#include "thread_pool.h"
	#include "well_known_classes.h"

	namespace art {
	namespace gc {

	static constexpr bool kAsyncReferenceQueueAdd = false;

	ReferenceProcessor::ReferenceProcessor()
	: collector_(nullptr),
	condition_("reference processor condition", *Locks::reference_processor_lock_) ,
	soft_reference_queue_(Locks::reference_queue_soft_references_lock_),
	weak_reference_queue_(Locks::reference_queue_weak_references_lock_),
	finalizer_reference_queue_(Locks::reference_queue_finalizer_references_lock_),
	phantom_reference_queue_(Locks::reference_queue_phantom_references_lock_),
	cleared_references_(Locks::reference_queue_cleared_references_lock_) {
	}

	static inline MemberOffset GetSlowPathFlagOffset(ObjPtr<mirror::Class> reference_class)
	REQUIRES_SHARED(Locks::mutator_lock_) {
	DCHECK(reference_class == GetClassRoot<mirror::Reference>());
	// Second static field
	ArtField* field = reference_class->GetStaticField(1);
	DCHECK_STREQ(field->GetName(), "slowPathEnabled");
	return field->GetOffset();
	}

	static inline void SetSlowPathFlag(bool enabled) REQUIRES_SHARED(Locks::mutator_lock_) {
	ObjPtr<mirror::Class> reference_class = GetClassRoot<mirror::Reference>();
	MemberOffset slow_path_offset = GetSlowPathFlagOffset(reference_class);
	reference_class->SetFieldBoolean</* kTransactionActive= / false, / kCheckTransaction= */ false>(
	slow_path_offset, enabled ? 1 : 0);
	}

	void ReferenceProcessor::EnableSlowPath() {
	SetSlowPathFlag(/* enabled= */ true);
	}

	void ReferenceProcessor::DisableSlowPath(Thread* self) {
	SetSlowPathFlag(/* enabled= */ false);
	condition_.Broadcast(self);
	}

	bool ReferenceProcessor::SlowPathEnabled() {
	ObjPtr<mirror::Class> reference_class = GetClassRoot<mirror::Reference>();
	MemberOffset slow_path_offset = GetSlowPathFlagOffset(reference_class);
	return reference_class->GetFieldBoolean(slow_path_offset);
	}

	void ReferenceProcessor::BroadcastForSlowPath(Thread* self) {
	MutexLock mu(self, *Locks::reference_processor_lock_);
	condition_.Broadcast(self);
	}

	ObjPtr<mirror::Object> ReferenceProcessor::GetReferent(Thread* self,
	ObjPtr<mirror::Reference> reference) {
	auto slow_path_required = [this, self]() REQUIRES_SHARED(Locks::mutator_lock_) {
	return gUseReadBarrier ? !self->GetWeakRefAccessEnabled() : SlowPathEnabled();
	};
	if (!slow_path_required()) {
	return reference->GetReferent();
	}
	// If the referent is null then it is already cleared, we can just return null since there is no
	// scenario where it becomes non-null during the reference processing phase.
	// A read barrier may be unsafe here, and we use the result only when it's null or marked.
	ObjPtr<mirror::Object> referent = reference->template GetReferent<kWithoutReadBarrier>();
	if (referent.IsNull()) {
	return referent;
	}

	bool started_trace = false;
	uint64_t start_millis;
	auto finish_trace = [](uint64_t start_millis) {
	ATraceEnd();
	uint64_t millis = MilliTime() - start_millis;
	static constexpr uint64_t kReportMillis = 10; // Long enough to risk dropped frames.
	if (millis > kReportMillis) {
	LOG(WARNING) << "Weak pointer dereference blocked for " << millis << " milliseconds.";
	}
	};

	MutexLock mu(self, *Locks::reference_processor_lock_);
	// Keeping reference_processor_lock_ blocks the broadcast when we try to reenable the fast path.
	while (slow_path_required()) {
	DCHECK(collector_ != nullptr);
	const bool other_read_barrier = !kUseBakerReadBarrier && gUseReadBarrier;
	if (UNLIKELY(reference->IsFinalizerReferenceInstance()
	\|\| rp_state_ == RpState::kStarting /* too early to determine mark state */
	\|\| (other_read_barrier && reference->IsPhantomReferenceInstance()))) {
	// Odd cases in which it doesn't hurt to just wait, or the wait is likely to be very brief.

	// Check and run the empty checkpoint before blocking so the empty checkpoint will work in the
	// presence of threads blocking for weak ref access.
	self->CheckEmptyCheckpointFromWeakRefAccess(Locks::reference_processor_lock_);
	if (!started_trace) {
	ATraceBegin("GetReferent blocked");
	started_trace = true;
	start_millis = MilliTime();
	}
	condition_.WaitHoldingLocks(self);
	continue;
	}
	DCHECK(!reference->IsPhantomReferenceInstance());

	if (rp_state_ == RpState::kInitClearingDone) {
	// Reachable references have their final referent values.
	break;
	}
	// Although reference processing is not done, we can always predict the correct return value
	// based on the current mark state. No additional marking from finalizers has been done, since
	// we hold reference_processor_lock_, which is required to advance to kInitClearingDone.
	DCHECK(rp_state_ == RpState::kInitMarkingDone);
	// Re-load and re-check referent, since the current one may have been read before we acquired
	// reference_lock. In particular a Reference.clear() call may have intervened. (b/33569625)
	referent = reference->GetReferent<kWithoutReadBarrier>();
	ObjPtr<mirror::Object> forwarded_ref =
	referent.IsNull() ? nullptr : collector_->IsMarked(referent.Ptr());
	// Either the referent was marked, and forwarded_ref is the correct return value, or it
	// was not, and forwarded_ref == null, which is again the correct return value.
	if (started_trace) {
	finish_trace(start_millis);
	}
	return forwarded_ref;
	}
	if (started_trace) {
	finish_trace(start_millis);
	}
	return reference->GetReferent();
	}

	// Forward SoftReferences. Can be done before we disable Reference access. Only
	// invoked if we are not clearing SoftReferences.
	uint32_t ReferenceProcessor::ForwardSoftReferences(TimingLogger* timings) {
	TimingLogger::ScopedTiming split(
	concurrent_ ? "ForwardSoftReferences" : "(Paused)ForwardSoftReferences", timings);
	// We used to argue that we should be smarter about doing this conditionally, but it's unclear
	// that's actually better than the more predictable strategy of basically only clearing
	// SoftReferences just before we would otherwise run out of memory.
	uint32_t non_null_refs = soft_reference_queue_.ForwardSoftReferences(collector_);
	if (ATraceEnabled()) {
	static constexpr size_t kBufSize = 80;
	char buf[kBufSize];
	snprintf(buf, kBufSize, "Marking for %" PRIu32 " SoftReferences", non_null_refs);
	ATraceBegin(buf);
	collector_->ProcessMarkStack();
	ATraceEnd();
	} else {
	collector_->ProcessMarkStack();
	}
	return non_null_refs;
	}

	void ReferenceProcessor::Setup(Thread* self,
	collector::GarbageCollector* collector,
	bool concurrent,
	bool clear_soft_references) {
	DCHECK(collector != nullptr);
	MutexLock mu(self, *Locks::reference_processor_lock_);
	collector_ = collector;
	rp_state_ = RpState::kStarting;
	concurrent_ = concurrent;
	clear_soft_references_ = clear_soft_references;
	}

	// Process reference class instances and schedule finalizations.
	// We advance rp_state_ to signal partial completion for the benefit of GetReferent.
	void ReferenceProcessor::ProcessReferences(Thread* self, TimingLogger* timings) {
	TimingLogger::ScopedTiming t(concurrent_ ? __FUNCTION__ : "(Paused)ProcessReferences", timings);
	if (!clear_soft_references_) {
	// Forward any additional SoftReferences we discovered late, now that reference access has been
	// inhibited.
	while (!soft_reference_queue_.IsEmpty()) {
	ForwardSoftReferences(timings);
	}
	}
	{
	MutexLock mu(self, *Locks::reference_processor_lock_);
	if (!gUseReadBarrier) {
	CHECK_EQ(SlowPathEnabled(), concurrent_) << "Slow path must be enabled iff concurrent";
	} else {
	// Weak ref access is enabled at Zygote compaction by SemiSpace (concurrent_ == false).
	CHECK_EQ(!self->GetWeakRefAccessEnabled(), concurrent_);
	}
	DCHECK(rp_state_ == RpState::kStarting);
	rp_state_ = RpState::kInitMarkingDone;
	condition_.Broadcast(self);
	}
	if (kIsDebugBuild && collector_->IsTransactionActive()) {
	// In transaction mode, we shouldn't enqueue any Reference to the queues.
	// See DelayReferenceReferent().
	DCHECK(soft_reference_queue_.IsEmpty());
	DCHECK(weak_reference_queue_.IsEmpty());
	DCHECK(finalizer_reference_queue_.IsEmpty());
	DCHECK(phantom_reference_queue_.IsEmpty());
	}
	// Clear all remaining soft and weak references with white referents.
	// This misses references only reachable through finalizers.
	soft_reference_queue_.ClearWhiteReferences(&cleared_references_, collector_);
	weak_reference_queue_.ClearWhiteReferences(&cleared_references_, collector_);
	// Defer PhantomReference processing until we've finished marking through finalizers.
	{
	// TODO: Capture mark state of some system weaks here. If the referent was marked here,
	// then it is now safe to return, since it can only refer to marked objects. If it becomes
	// marked below, that is no longer guaranteed.
	MutexLock mu(self, *Locks::reference_processor_lock_);
	rp_state_ = RpState::kInitClearingDone;
	// At this point, all mutator-accessible data is marked (black). Objects enqueued for
	// finalization will only be made available to the mutator via CollectClearedReferences after
	// we're fully done marking. Soft and WeakReferences accessible to the mutator have been
	// processed and refer only to black objects. Thus there is no danger of the mutator getting
	// access to non-black objects. Weak reference processing is still nominally suspended,
	// But many kinds of references, including all java.lang.ref ones, are handled normally from
	// here on. See GetReferent().
	}
	{
	TimingLogger::ScopedTiming t2(
	concurrent_ ? "EnqueueFinalizerReferences" : "(Paused)EnqueueFinalizerReferences", timings);
	// Preserve all white objects with finalize methods and schedule them for finalization.
	FinalizerStats finalizer_stats =
	finalizer_reference_queue_.EnqueueFinalizerReferences(&cleared_references_, collector_);
	if (ATraceEnabled()) {
	static constexpr size_t kBufSize = 80;
	char buf[kBufSize];
	snprintf(buf, kBufSize, "Marking from %" PRIu32 " / %" PRIu32 " finalizers",
	finalizer_stats.num_enqueued_, finalizer_stats.num_refs_);
	ATraceBegin(buf);
	collector_->ProcessMarkStack();
	ATraceEnd();
	} else {
	collector_->ProcessMarkStack();
	}
	}

	// Process all soft and weak references with white referents, where the references are reachable
	// only from finalizers. It is unclear that there is any way to do this without slightly
	// violating some language spec. We choose to apply normal Reference processing rules for these.
	// This exposes the following issues:
	// 1) In the case of an unmarked referent, we may end up enqueuing an "unreachable" reference.
	// This appears unavoidable, since we need to clear the reference for safety, unless we
	// mark the referent and undo finalization decisions for objects we encounter during marking.
	// (Some versions of the RI seem to do something along these lines.)
	// Or we could clear the reference without enqueuing it, which also seems strange and
	// unhelpful.
	// 2) In the case of a marked referent, we will preserve a reference to objects that may have
	// been enqueued for finalization. Again fixing this would seem to involve at least undoing
	// previous finalization / reference clearing decisions. (This would also mean than an object
	// containing both a strong and a WeakReference to the same referent could see the
	// WeakReference cleared.)
	// The treatment in (2) is potentially quite dangerous, since Reference.get() can e.g. return a
	// finalized object containing pointers to native objects that have already been deallocated.
	// But it can be argued that this is just an instance of the broader rule that it is not safe
	// for finalizers to access otherwise inaccessible finalizable objects.
	soft_reference_queue_.ClearWhiteReferences(&cleared_references_, collector_,
	/report_cleared=/ true);
	weak_reference_queue_.ClearWhiteReferences(&cleared_references_, collector_,
	/report_cleared=/ true);

	// Clear all phantom references with white referents. It's fine to do this just once here.
	phantom_reference_queue_.ClearWhiteReferences(&cleared_references_, collector_);

	// At this point all reference queues other than the cleared references should be empty.
	DCHECK(soft_reference_queue_.IsEmpty());
	DCHECK(weak_reference_queue_.IsEmpty());
	DCHECK(finalizer_reference_queue_.IsEmpty());
	DCHECK(phantom_reference_queue_.IsEmpty());

	{
	MutexLock mu(self, *Locks::reference_processor_lock_);
	// Need to always do this since the next GC may be concurrent. Doing this for only concurrent
	// could result in a stale is_marked_callback_ being called before the reference processing
	// starts since there is a small window of time where slow_path_enabled_ is enabled but the
	// callback isn't yet set.
	if (!gUseReadBarrier && concurrent_) {
	// Done processing, disable the slow path and broadcast to the waiters.
	DisableSlowPath(self);
	}
	}
	}

	// Process the "referent" field in a java.lang.ref.Reference. If the referent has not yet been
	// marked, put it on the appropriate list in the heap for later processing.
	void ReferenceProcessor::DelayReferenceReferent(ObjPtr<mirror::Class> klass,
	ObjPtr<mirror::Reference> ref,
	collector::GarbageCollector* collector) {
	// klass can be the class of the old object if the visitor already updated the class of ref.
	DCHECK(klass != nullptr);
	DCHECK(klass->IsTypeOfReferenceClass());
	mirror::HeapReference<mirror::Object>* referent = ref->GetReferentReferenceAddr();
	// do_atomic_update needs to be true because this happens outside of the reference processing
	// phase.
	if (!collector->IsNullOrMarkedHeapReference(referent, /do_atomic_update=/true)) {
	if (UNLIKELY(collector->IsTransactionActive())) {
	// In transaction mode, keep the referent alive and avoid any reference processing to avoid the
	// issue of rolling back reference processing. do_atomic_update needs to be true because this
	// happens outside of the reference processing phase.
	if (!referent->IsNull()) {
	collector->MarkHeapReference(referent, /do_atomic_update=/ true);
	}
	return;
	}
	Thread* self = Thread::Current();
	// TODO: Remove these locks, and use atomic stacks for storing references?
	// We need to check that the references haven't already been enqueued since we can end up
	// scanning the same reference multiple times due to dirty cards.
	if (klass->IsSoftReferenceClass()) {
	soft_reference_queue_.AtomicEnqueueIfNotEnqueued(self, ref);
	} else if (klass->IsWeakReferenceClass()) {
	weak_reference_queue_.AtomicEnqueueIfNotEnqueued(self, ref);
	} else if (klass->IsFinalizerReferenceClass()) {
	finalizer_reference_queue_.AtomicEnqueueIfNotEnqueued(self, ref);
	} else if (klass->IsPhantomReferenceClass()) {
	phantom_reference_queue_.AtomicEnqueueIfNotEnqueued(self, ref);
	} else {
	LOG(FATAL) << "Invalid reference type " << klass->PrettyClass() << " " << std::hex
	<< klass->GetAccessFlags();
	}
	}
	}

	void ReferenceProcessor::UpdateRoots(IsMarkedVisitor* visitor) {
	cleared_references_.UpdateRoots(visitor);
	}

	class ClearedReferenceTask : public HeapTask {
	public:
	explicit ClearedReferenceTask(jobject cleared_references)
	: HeapTask(NanoTime()), cleared_references_(cleared_references) {
	}
	void Run(Thread* thread) override {
	ScopedObjectAccess soa(thread);
	WellKnownClasses::java_lang_ref_ReferenceQueue_add->InvokeStatic<'V', 'L'>(
	thread, soa.Decode<mirror::Object>(cleared_references_));
	soa.Env()->DeleteGlobalRef(cleared_references_);
	}

	private:
	const jobject cleared_references_;
	};

	SelfDeletingTask* ReferenceProcessor::CollectClearedReferences(Thread* self) {
	Locks::mutator_lock_->AssertNotHeld(self);
	// By default we don't actually need to do anything. Just return this no-op task to avoid having
	// to put in ifs.
	std::unique_ptr<SelfDeletingTask> result(new FunctionTask([](Thread*) {}));
	// When a runtime isn't started there are no reference queues to care about so ignore.
	if (!cleared_references_.IsEmpty()) {
	if (LIKELY(Runtime::Current()->IsStarted())) {
	jobject cleared_references;
	{
	ReaderMutexLock mu(self, *Locks::mutator_lock_);
	cleared_references = self->GetJniEnv()->GetVm()->AddGlobalRef(
	self, cleared_references_.GetList());
	}
	if (kAsyncReferenceQueueAdd) {
	// TODO: This can cause RunFinalization to terminate before newly freed objects are
	// finalized since they may not be enqueued by the time RunFinalization starts.
	Runtime::Current()->GetHeap()->GetTaskProcessor()->AddTask(
	self, new ClearedReferenceTask(cleared_references));
	} else {
	result.reset(new ClearedReferenceTask(cleared_references));
	}
	}
	cleared_references_.Clear();
	}
	return result.release();
	}

	void ReferenceProcessor::ClearReferent(ObjPtr<mirror::Reference> ref) {
	Thread* self = Thread::Current();
	MutexLock mu(self, *Locks::reference_processor_lock_);
	// Need to wait until reference processing is done since IsMarkedHeapReference does not have a
	// CAS. If we do not wait, it can result in the GC un-clearing references due to race conditions.
	// This also handles the race where the referent gets cleared after a null check but before
	// IsMarkedHeapReference is called.
	WaitUntilDoneProcessingReferences(self);
	if (Runtime::Current()->IsActiveTransaction()) {
	ref->ClearReferent<true>();
	} else {
	ref->ClearReferent<false>();
	}
	}

	void ReferenceProcessor::WaitUntilDoneProcessingReferences(Thread* self) {
	// Wait until we are done processing reference.
	while ((!gUseReadBarrier && SlowPathEnabled()) \|\|
	(gUseReadBarrier && !self->GetWeakRefAccessEnabled())) {
	// Check and run the empty checkpoint before blocking so the empty checkpoint will work in the
	// presence of threads blocking for weak ref access.
	self->CheckEmptyCheckpointFromWeakRefAccess(Locks::reference_processor_lock_);
	condition_.WaitHoldingLocks(self);
	}
	}

	bool ReferenceProcessor::MakeCircularListIfUnenqueued(
	ObjPtr<mirror::FinalizerReference> reference) {
	Thread* self = Thread::Current();
	MutexLock mu(self, *Locks::reference_processor_lock_);
	WaitUntilDoneProcessingReferences(self);
	// At this point, since the sentinel of the reference is live, it is guaranteed to not be
	// enqueued if we just finished processing references. Otherwise, we may be doing the main GC
	// phase. Since we are holding the reference processor lock, it guarantees that reference
	// processing can't begin. The GC could have just enqueued the reference one one of the internal
	// GC queues, but since we hold the lock finalizer_reference_queue_ lock it also prevents this
	// race.
	MutexLock mu2(self, *Locks::reference_queue_finalizer_references_lock_);
	if (reference->IsUnprocessed()) {
	CHECK(reference->IsFinalizerReferenceInstance());
	reference->SetPendingNext(reference);
	return true;
	}
	return false;
	}

	} // namespace gc
	} // namespace art