blob: 5eb095b3647c654fc119cf7407a153e3ce437264 [file] [log] [blame]
Mathieu Chartier78f7b4c2014-05-06 10:57:27 -07001/*
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
26namespace art {
27
28class TimingLogger;
29
30namespace mirror {
Mathieu Chartiera5a53ef2014-09-12 12:58:05 -070031class FinalizerReference;
Mathieu Chartier78f7b4c2014-05-06 10:57:27 -070032class Object;
33class Reference;
34} // namespace mirror
35
36namespace gc {
37
38class Heap;
39
40// Used to process java.lang.References concurrently or paused.
41class ReferenceProcessor {
42 public:
43 explicit ReferenceProcessor();
Mathieu Chartier308351a2014-06-15 12:39:02 -070044 static bool PreserveSoftReferenceCallback(mirror::HeapReference<mirror::Object>* obj, void* arg)
45 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartier78f7b4c2014-05-06 10:57:27 -070046 void ProcessReferences(bool concurrent, TimingLogger* timings, bool clear_soft_references,
Mathieu Chartier308351a2014-06-15 12:39:02 -070047 IsHeapReferenceMarkedCallback* is_marked_callback,
Mathieu Chartier78f7b4c2014-05-06 10:57:27 -070048 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_)
Mathieu Chartiera5a53ef2014-09-12 12:58:05 -070052 LOCKS_EXCLUDED(Locks::reference_processor_lock_);
Fred Shih4ee7a662014-07-11 09:59:27 -070053 // The slow path bool is contained in the reference class object, can only be set once
Mathieu Chartier78f7b4c2014-05-06 10:57:27 -070054 // 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)
Mathieu Chartiera5a53ef2014-09-12 12:58:05 -070059 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) LOCKS_EXCLUDED(Locks::reference_processor_lock_);
Mathieu Chartier308351a2014-06-15 12:39:02 -070060 void EnqueueClearedReferences(Thread* self) LOCKS_EXCLUDED(Locks::mutator_lock_);
Mathieu Chartier78f7b4c2014-05-06 10:57:27 -070061 void DelayReferenceReferent(mirror::Class* klass, mirror::Reference* ref,
Mathieu Chartier308351a2014-06-15 12:39:02 -070062 IsHeapReferenceMarkedCallback* is_marked_callback, void* arg)
Mathieu Chartier78f7b4c2014-05-06 10:57:27 -070063 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartier52e4b432014-06-10 11:22:31 -070064 void UpdateRoots(IsMarkedCallback* callback, void* arg)
Fred Shih4ee7a662014-07-11 09:59:27 -070065 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_, Locks::heap_bitmap_lock_);
Mathieu Chartiera5a53ef2014-09-12 12:58:05 -070066 // 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_);
Mathieu Chartier78f7b4c2014-05-06 10:57:27 -070071
72 private:
73 class ProcessReferencesArgs {
74 public:
Mathieu Chartier308351a2014-06-15 12:39:02 -070075 ProcessReferencesArgs(IsHeapReferenceMarkedCallback* is_marked_callback,
Mathieu Chartier78f7b4c2014-05-06 10:57:27 -070076 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.
Mathieu Chartier308351a2014-06-15 12:39:02 -070081 IsHeapReferenceMarkedCallback* is_marked_callback_;
Mathieu Chartier78f7b4c2014-05-06 10:57:27 -070082 MarkObjectCallback* mark_callback_;
83 void* arg_;
84 };
Fred Shih4ee7a662014-07-11 09:59:27 -070085 bool SlowPathEnabled() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartier78f7b4c2014-05-06 10:57:27 -070086 // Called by ProcessReferences.
Mathieu Chartiera5a53ef2014-09-12 12:58:05 -070087 void DisableSlowPath(Thread* self) EXCLUSIVE_LOCKS_REQUIRED(Locks::reference_processor_lock_)
Fred Shih4ee7a662014-07-11 09:59:27 -070088 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartier78f7b4c2014-05-06 10:57:27 -070089 // 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.
Mathieu Chartiera5a53ef2014-09-12 12:58:05 -070092 void StartPreservingReferences(Thread* self) LOCKS_EXCLUDED(Locks::reference_processor_lock_);
93 void StopPreservingReferences(Thread* self) LOCKS_EXCLUDED(Locks::reference_processor_lock_);
Mathieu Chartier78f7b4c2014-05-06 10:57:27 -070094 // Process args, used by the GetReferent to return referents which are already marked.
Mathieu Chartiera5a53ef2014-09-12 12:58:05 -070095 ProcessReferencesArgs process_references_args_ GUARDED_BY(Locks::reference_processor_lock_);
Mathieu Chartier78f7b4c2014-05-06 10:57:27 -070096 // 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).
Mathieu Chartiera5a53ef2014-09-12 12:58:05 -070098 bool preserving_references_ GUARDED_BY(Locks::reference_processor_lock_);
Mathieu Chartier78f7b4c2014-05-06 10:57:27 -070099 // Condition that people wait on if they attempt to get the referent of a reference while
100 // processing is in progress.
Mathieu Chartiera5a53ef2014-09-12 12:58:05 -0700101 ConditionVariable condition_ GUARDED_BY(Locks::reference_processor_lock_);
Mathieu Chartier78f7b4c2014-05-06 10:57:27 -0700102 // 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_