Home | History | Annotate | Download | only in gc 
      1 /*
      2  * Copyright (C) 2014 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 
     17 #ifndef ART_RUNTIME_GC_REFERENCE_PROCESSOR_H_
     18 #define ART_RUNTIME_GC_REFERENCE_PROCESSOR_H_
     19 
     20 #include "base/mutex.h"
     21 #include "globals.h"
     22 #include "jni.h"
     23 #include "object_callbacks.h"
     24 #include "reference_queue.h"
     25 
     26 namespace art {
     27 
     28 class TimingLogger;
     29 
     30 namespace mirror {
     31 class FinalizerReference;
     32 class Object;
     33 class Reference;
     34 }  // namespace mirror
     35 
     36 namespace gc {
     37 
     38 class Heap;
     39 
     40 // Used to process java.lang.References concurrently or paused.
     41 class ReferenceProcessor {
     42  public:
     43   explicit ReferenceProcessor();
     44   static bool PreserveSoftReferenceCallback(mirror::HeapReference<mirror::Object>* obj, void* arg)
     45       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
     46   void ProcessReferences(bool concurrent, TimingLogger* timings, bool clear_soft_references,
     47                          IsHeapReferenceMarkedCallback* is_marked_callback,
     48                          MarkObjectCallback* mark_object_callback,
     49                          ProcessMarkStackCallback* process_mark_stack_callback, void* arg)
     50       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
     51       EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_)
     52       LOCKS_EXCLUDED(Locks::reference_processor_lock_);
     53   // The slow path bool is contained in the reference class object, can only be set once
     54   // Only allow setting this with mutators suspended so that we can avoid using a lock in the
     55   // GetReferent fast path as an optimization.
     56   void EnableSlowPath() EXCLUSIVE_LOCKS_REQUIRED(Locks::mutator_lock_);
     57   // Decode the referent, may block if references are being processed.
     58   mirror::Object* GetReferent(Thread* self, mirror::Reference* reference)
     59       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) LOCKS_EXCLUDED(Locks::reference_processor_lock_);
     60   void EnqueueClearedReferences(Thread* self) LOCKS_EXCLUDED(Locks::mutator_lock_);
     61   void DelayReferenceReferent(mirror::Class* klass, mirror::Reference* ref,
     62                               IsHeapReferenceMarkedCallback* is_marked_callback, void* arg)
     63       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
     64   void UpdateRoots(IsMarkedCallback* callback, void* arg)
     65       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_, Locks::heap_bitmap_lock_);
     66   // Make a circular list with reference if it is not enqueued. Uses the finalizer queue lock.
     67   bool MakeCircularListIfUnenqueued(mirror::FinalizerReference* reference)
     68       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
     69       LOCKS_EXCLUDED(Locks::reference_processor_lock_,
     70                      Locks::reference_queue_finalizer_references_lock_);
     71 
     72  private:
     73   class ProcessReferencesArgs {
     74    public:
     75     ProcessReferencesArgs(IsHeapReferenceMarkedCallback* is_marked_callback,
     76                           MarkObjectCallback* mark_callback, void* arg)
     77         : is_marked_callback_(is_marked_callback), mark_callback_(mark_callback), arg_(arg) {
     78     }
     79 
     80     // The is marked callback is null when the args aren't set up.
     81     IsHeapReferenceMarkedCallback* is_marked_callback_;
     82     MarkObjectCallback* mark_callback_;
     83     void* arg_;
     84   };
     85   bool SlowPathEnabled() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
     86   // Called by ProcessReferences.
     87   void DisableSlowPath(Thread* self) EXCLUSIVE_LOCKS_REQUIRED(Locks::reference_processor_lock_)
     88       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
     89   // If we are preserving references it means that some dead objects may become live, we use start
     90   // and stop preserving to block mutators using GetReferrent from getting access to these
     91   // referents.
     92   void StartPreservingReferences(Thread* self) LOCKS_EXCLUDED(Locks::reference_processor_lock_);
     93   void StopPreservingReferences(Thread* self) LOCKS_EXCLUDED(Locks::reference_processor_lock_);
     94   // Process args, used by the GetReferent to return referents which are already marked.
     95   ProcessReferencesArgs process_references_args_ GUARDED_BY(Locks::reference_processor_lock_);
     96   // Boolean for whether or not we are preserving references (either soft references or finalizers).
     97   // If this is true, then we cannot return a referent (see comment in GetReferent).
     98   bool preserving_references_ GUARDED_BY(Locks::reference_processor_lock_);
     99   // Condition that people wait on if they attempt to get the referent of a reference while
    100   // processing is in progress.
    101   ConditionVariable condition_ GUARDED_BY(Locks::reference_processor_lock_);
    102   // Reference queues used by the GC.
    103   ReferenceQueue soft_reference_queue_;
    104   ReferenceQueue weak_reference_queue_;
    105   ReferenceQueue finalizer_reference_queue_;
    106   ReferenceQueue phantom_reference_queue_;
    107   ReferenceQueue cleared_references_;
    108 };
    109 
    110 }  // namespace gc
    111 }  // namespace art
    112 
    113 #endif  // ART_RUNTIME_GC_REFERENCE_PROCESSOR_H_
    114