Mathieu Chartier | 39e3261 | 2013-11-12 16:28:05 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2013 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_QUEUE_H_ |
| 18 | #define ART_RUNTIME_GC_REFERENCE_QUEUE_H_ |
| 19 | |
| 20 | #include <iosfwd> |
| 21 | #include <string> |
| 22 | #include <vector> |
| 23 | |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 24 | #include "atomic.h" |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 25 | #include "base/mutex.h" |
Mathieu Chartier | 39e3261 | 2013-11-12 16:28:05 -0800 | [diff] [blame] | 26 | #include "base/timing_logger.h" |
| 27 | #include "globals.h" |
Mathieu Chartier | 39e3261 | 2013-11-12 16:28:05 -0800 | [diff] [blame] | 28 | #include "jni.h" |
Mathieu Chartier | 83c8ee0 | 2014-01-28 14:50:23 -0800 | [diff] [blame] | 29 | #include "object_callbacks.h" |
Mathieu Chartier | 39e3261 | 2013-11-12 16:28:05 -0800 | [diff] [blame] | 30 | #include "offsets.h" |
Mathieu Chartier | 39e3261 | 2013-11-12 16:28:05 -0800 | [diff] [blame] | 31 | #include "thread_pool.h" |
| 32 | |
| 33 | namespace art { |
Mathieu Chartier | 8fa2dad | 2014-03-13 12:22:56 -0700 | [diff] [blame] | 34 | namespace mirror { |
| 35 | class Reference; |
| 36 | } // namespace mirror |
| 37 | |
Mathieu Chartier | 39e3261 | 2013-11-12 16:28:05 -0800 | [diff] [blame] | 38 | namespace gc { |
| 39 | |
Mathieu Chartier | 9750995 | 2015-07-13 14:35:43 -0700 | [diff] [blame] | 40 | namespace collector { |
| 41 | class GarbageCollector; |
| 42 | } // namespace collector |
| 43 | |
Mathieu Chartier | 39e3261 | 2013-11-12 16:28:05 -0800 | [diff] [blame] | 44 | class Heap; |
| 45 | |
| 46 | // Used to temporarily store java.lang.ref.Reference(s) during GC and prior to queueing on the |
Richard Uhler | c4695df | 2016-01-15 14:08:05 -0800 | [diff] [blame] | 47 | // appropriate java.lang.ref.ReferenceQueue. The linked list is maintained as an unordered, |
| 48 | // circular, and singly-linked list using the pendingNext fields of the java.lang.ref.Reference |
| 49 | // objects. |
Mathieu Chartier | 39e3261 | 2013-11-12 16:28:05 -0800 | [diff] [blame] | 50 | class ReferenceQueue { |
| 51 | public: |
Mathieu Chartier | a5a53ef | 2014-09-12 12:58:05 -0700 | [diff] [blame] | 52 | explicit ReferenceQueue(Mutex* lock); |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 53 | |
Richard Uhler | c4695df | 2016-01-15 14:08:05 -0800 | [diff] [blame] | 54 | // Enqueue a reference if it is unprocessed. Thread safe to call from multiple |
| 55 | // threads since it uses a lock to avoid a race between checking for the references presence and |
| 56 | // adding it. |
Mathieu Chartier | 8fa2dad | 2014-03-13 12:22:56 -0700 | [diff] [blame] | 57 | void AtomicEnqueueIfNotEnqueued(Thread* self, mirror::Reference* ref) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 58 | SHARED_REQUIRES(Locks::mutator_lock_) REQUIRES(!*lock_); |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 59 | |
Richard Uhler | c4695df | 2016-01-15 14:08:05 -0800 | [diff] [blame] | 60 | // Enqueue a reference. The reference must be unprocessed. |
| 61 | // Not thread safe, used when mutators are paused to minimize lock overhead. |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 62 | void EnqueueReference(mirror::Reference* ref) SHARED_REQUIRES(Locks::mutator_lock_); |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 63 | |
Richard Uhler | c4695df | 2016-01-15 14:08:05 -0800 | [diff] [blame] | 64 | // Dequeue a reference from the queue and return that dequeued reference. |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 65 | mirror::Reference* DequeuePendingReference() SHARED_REQUIRES(Locks::mutator_lock_); |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 66 | |
Mathieu Chartier | 9e2094f | 2014-12-11 18:43:48 -0800 | [diff] [blame] | 67 | // Enqueues finalizer references with white referents. White referents are blackened, moved to |
| 68 | // the zombie field, and the referent field is cleared. |
Mathieu Chartier | 308351a | 2014-06-15 12:39:02 -0700 | [diff] [blame] | 69 | void EnqueueFinalizerReferences(ReferenceQueue* cleared_references, |
Mathieu Chartier | 9750995 | 2015-07-13 14:35:43 -0700 | [diff] [blame] | 70 | collector::GarbageCollector* collector) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 71 | SHARED_REQUIRES(Locks::mutator_lock_); |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 72 | |
Mathieu Chartier | 39e3261 | 2013-11-12 16:28:05 -0800 | [diff] [blame] | 73 | // Walks the reference list marking any references subject to the reference clearing policy. |
| 74 | // References with a black referent are removed from the list. References with white referents |
| 75 | // biased toward saving are blackened and also removed from the list. |
Mathieu Chartier | 9750995 | 2015-07-13 14:35:43 -0700 | [diff] [blame] | 76 | void ForwardSoftReferences(MarkObjectVisitor* visitor) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 77 | SHARED_REQUIRES(Locks::mutator_lock_); |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 78 | |
Mathieu Chartier | 9e2094f | 2014-12-11 18:43:48 -0800 | [diff] [blame] | 79 | // Unlink the reference list clearing references objects with white referents. Cleared references |
Mathieu Chartier | 39e3261 | 2013-11-12 16:28:05 -0800 | [diff] [blame] | 80 | // registered to a reference queue are scheduled for appending by the heap worker thread. |
Mathieu Chartier | 308351a | 2014-06-15 12:39:02 -0700 | [diff] [blame] | 81 | void ClearWhiteReferences(ReferenceQueue* cleared_references, |
Mathieu Chartier | 9750995 | 2015-07-13 14:35:43 -0700 | [diff] [blame] | 82 | collector::GarbageCollector* collector) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 83 | SHARED_REQUIRES(Locks::mutator_lock_); |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 84 | |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 85 | void Dump(std::ostream& os) const SHARED_REQUIRES(Locks::mutator_lock_); |
| 86 | size_t GetLength() const SHARED_REQUIRES(Locks::mutator_lock_); |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 87 | |
Mathieu Chartier | 39e3261 | 2013-11-12 16:28:05 -0800 | [diff] [blame] | 88 | bool IsEmpty() const { |
| 89 | return list_ == nullptr; |
| 90 | } |
| 91 | void Clear() { |
| 92 | list_ = nullptr; |
| 93 | } |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 94 | mirror::Reference* GetList() SHARED_REQUIRES(Locks::mutator_lock_) { |
Mathieu Chartier | 39e3261 | 2013-11-12 16:28:05 -0800 | [diff] [blame] | 95 | return list_; |
| 96 | } |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 97 | |
Mathieu Chartier | 52e4b43 | 2014-06-10 11:22:31 -0700 | [diff] [blame] | 98 | // Visits list_, currently only used for the mark compact GC. |
Mathieu Chartier | 9750995 | 2015-07-13 14:35:43 -0700 | [diff] [blame] | 99 | void UpdateRoots(IsMarkedVisitor* visitor) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 100 | SHARED_REQUIRES(Locks::mutator_lock_); |
Mathieu Chartier | 39e3261 | 2013-11-12 16:28:05 -0800 | [diff] [blame] | 101 | |
| 102 | private: |
| 103 | // Lock, used for parallel GC reference enqueuing. It allows for multiple threads simultaneously |
| 104 | // calling AtomicEnqueueIfNotEnqueued. |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 105 | Mutex* const lock_; |
Mathieu Chartier | 52e4b43 | 2014-06-10 11:22:31 -0700 | [diff] [blame] | 106 | // The actual reference list. Only a root for the mark compact GC since it will be null for other |
| 107 | // GC types. |
Mathieu Chartier | 8fa2dad | 2014-03-13 12:22:56 -0700 | [diff] [blame] | 108 | mirror::Reference* list_; |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 109 | |
Mathieu Chartier | 3130cdf | 2015-05-03 15:20:23 -0700 | [diff] [blame] | 110 | DISALLOW_IMPLICIT_CONSTRUCTORS(ReferenceQueue); |
Mathieu Chartier | 39e3261 | 2013-11-12 16:28:05 -0800 | [diff] [blame] | 111 | }; |
| 112 | |
| 113 | } // namespace gc |
| 114 | } // namespace art |
| 115 | |
| 116 | #endif // ART_RUNTIME_GC_REFERENCE_QUEUE_H_ |