blob: 49b6a38b01d786602460394e28290b28904863ca [file] [log] [blame]
Elliott Hughes11e45072011-08-16 17:40:46 -07001/*
2 * Copyright (C) 2008 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#include "reference_table.h"
18
Elliott Hughes76b61672012-12-12 17:47:30 -080019#include "base/mutex.h"
Elliott Hughes6c1a3942011-08-17 15:00:06 -070020#include "indirect_reference_table.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080021#include "mirror/array.h"
22#include "mirror/array-inl.h"
23#include "mirror/class.h"
24#include "mirror/class-inl.h"
25#include "mirror/object-inl.h"
Ian Rogersb0fa5dc2014-04-28 16:47:08 -070026#include "mirror/string-inl.h"
Ian Rogersc0542af2014-09-03 16:16:56 -070027#include "runtime-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080028#include "thread.h"
29#include "utils.h"
Elliott Hughes11e45072011-08-16 17:40:46 -070030
31namespace art {
32
Elliott Hughesbb1e8f02011-10-18 14:14:25 -070033ReferenceTable::ReferenceTable(const char* name, size_t initial_size, size_t max_size)
34 : name_(name), max_size_(max_size) {
Elliott Hughes11e45072011-08-16 17:40:46 -070035 CHECK_LE(initial_size, max_size);
36 entries_.reserve(initial_size);
37}
38
Elliott Hughesc1674ed2011-08-25 18:09:09 -070039ReferenceTable::~ReferenceTable() {
40}
41
Mathieu Chartier423d2a32013-09-12 17:33:56 -070042void ReferenceTable::Add(mirror::Object* obj) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -070043 DCHECK(obj != nullptr);
Mathieu Chartierc645f1d2014-03-06 18:11:53 -080044 VerifyObject(obj);
Mathieu Chartier423d2a32013-09-12 17:33:56 -070045 if (entries_.size() >= max_size_) {
Elliott Hughes11e45072011-08-16 17:40:46 -070046 LOG(FATAL) << "ReferenceTable '" << name_ << "' "
47 << "overflowed (" << max_size_ << " entries)";
48 }
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -070049 entries_.push_back(GcRoot<mirror::Object>(obj));
Elliott Hughes11e45072011-08-16 17:40:46 -070050}
51
Mathieu Chartier423d2a32013-09-12 17:33:56 -070052void ReferenceTable::Remove(mirror::Object* obj) {
Elliott Hughes11e45072011-08-16 17:40:46 -070053 // We iterate backwards on the assumption that references are LIFO.
54 for (int i = entries_.size() - 1; i >= 0; --i) {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -070055 mirror::Object* entry = entries_[i].Read();
Hiroshi Yamauchiea2e1bd2014-06-18 13:47:35 -070056 if (entry == obj) {
Elliott Hughes11e45072011-08-16 17:40:46 -070057 entries_.erase(entries_.begin() + i);
58 return;
59 }
60 }
61}
62
Carl Shapiro5b1982d2011-08-16 18:35:19 -070063// If "obj" is an array, return the number of elements in the array.
64// Otherwise, return zero.
Mathieu Chartier90443472015-07-16 20:32:27 -070065static size_t GetElementCount(mirror::Object* obj) SHARED_REQUIRES(Locks::mutator_lock_) {
Ian Rogersc0542af2014-09-03 16:16:56 -070066 // We assume the special cleared value isn't an array in the if statement below.
67 DCHECK(!Runtime::Current()->GetClearedJniWeakGlobal()->IsArrayInstance());
68 if (obj == nullptr || !obj->IsArrayInstance()) {
Elliott Hughes11e45072011-08-16 17:40:46 -070069 return 0;
70 }
71 return obj->AsArray()->GetLength();
72}
73
Carl Shapiro5b1982d2011-08-16 18:35:19 -070074// Log an object with some additional info.
75//
76// Pass in the number of elements in the array (or 0 if this is not an
77// array object), and the number of additional objects that are identical
78// or equivalent to the original.
Ian Rogersef7d42f2014-01-06 12:55:46 -080079static void DumpSummaryLine(std::ostream& os, mirror::Object* obj, size_t element_count,
Ian Rogers00f7d0e2012-07-19 15:28:27 -070080 int identical, int equiv)
Mathieu Chartier90443472015-07-16 20:32:27 -070081 SHARED_REQUIRES(Locks::mutator_lock_) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -070082 if (obj == nullptr) {
83 os << " null reference (count=" << equiv << ")\n";
Elliott Hughes11e45072011-08-16 17:40:46 -070084 return;
85 }
Ian Rogersc0542af2014-09-03 16:16:56 -070086 if (Runtime::Current()->IsClearedJniWeakGlobal(obj)) {
Elliott Hughes73e66f72012-05-09 09:34:45 -070087 os << " cleared jweak (count=" << equiv << ")\n";
Elliott Hughes11e45072011-08-16 17:40:46 -070088 return;
89 }
90
Elliott Hughes54e7df12011-09-16 11:47:04 -070091 std::string className(PrettyTypeOf(obj));
Elliott Hughes11e45072011-08-16 17:40:46 -070092 if (obj->IsClass()) {
93 // We're summarizing multiple instances, so using the exemplar
94 // Class' type parameter here would be misleading.
95 className = "java.lang.Class";
96 }
Elliott Hughes73e66f72012-05-09 09:34:45 -070097 if (element_count != 0) {
98 StringAppendF(&className, " (%zd elements)", element_count);
Elliott Hughes11e45072011-08-16 17:40:46 -070099 }
100
101 size_t total = identical + equiv + 1;
Elliott Hughes215f3142012-01-19 00:22:47 -0800102 std::string msg(StringPrintf("%5zd of %s", total, className.c_str()));
Elliott Hughes11e45072011-08-16 17:40:46 -0700103 if (identical + equiv != 0) {
104 StringAppendF(&msg, " (%d unique instances)", equiv + 1);
105 }
Elliott Hughes73e66f72012-05-09 09:34:45 -0700106 os << " " << msg << "\n";
Elliott Hughes11e45072011-08-16 17:40:46 -0700107}
108
109size_t ReferenceTable::Size() const {
110 return entries_.size();
111}
112
Hiroshi Yamauchiea2e1bd2014-06-18 13:47:35 -0700113void ReferenceTable::Dump(std::ostream& os) {
Elliott Hughes73e66f72012-05-09 09:34:45 -0700114 os << name_ << " reference table dump:\n";
115 Dump(os, entries_);
Elliott Hughes6c1a3942011-08-17 15:00:06 -0700116}
Elliott Hughes11e45072011-08-16 17:40:46 -0700117
Hiroshi Yamauchiea2e1bd2014-06-18 13:47:35 -0700118void ReferenceTable::Dump(std::ostream& os, Table& entries) {
Mathieu Chartier4c4d6092015-01-22 17:02:27 -0800119 // Compare GC roots, first by class, then size, then address.
120 struct GcRootComparator {
121 bool operator()(GcRoot<mirror::Object> root1, GcRoot<mirror::Object> root2) const
122 // TODO: enable analysis when analysis can work with the STL.
123 NO_THREAD_SAFETY_ANALYSIS {
124 Locks::mutator_lock_->AssertSharedHeld(Thread::Current());
125 // These GC roots are already forwarded in ReferenceTable::Dump. We sort by class since there
126 // are no suspend points which can happen during the sorting process. This works since
127 // we are guaranteed that the addresses of obj1, obj2, obj1->GetClass, obj2->GetClass wont
128 // change during the sorting process. The classes are forwarded by ref->GetClass().
129 mirror::Object* obj1 = root1.Read<kWithoutReadBarrier>();
130 mirror::Object* obj2 = root2.Read<kWithoutReadBarrier>();
131 DCHECK(obj1 != nullptr);
132 DCHECK(obj2 != nullptr);
133 Runtime* runtime = Runtime::Current();
134 DCHECK(!runtime->IsClearedJniWeakGlobal(obj1));
135 DCHECK(!runtime->IsClearedJniWeakGlobal(obj2));
136 // Sort by class...
137 if (obj1->GetClass() != obj2->GetClass()) {
138 return obj1->GetClass() < obj2->GetClass();
139 }
140 // ...then by size...
141 const size_t size1 = obj1->SizeOf();
142 const size_t size2 = obj2->SizeOf();
143 if (size1 != size2) {
144 return size1 < size2;
145 }
146 // ...and finally by address.
147 return obj1 < obj2;
148 }
149 };
150
Elliott Hughes6c1a3942011-08-17 15:00:06 -0700151 if (entries.empty()) {
Elliott Hughes73e66f72012-05-09 09:34:45 -0700152 os << " (empty)\n";
Elliott Hughes11e45072011-08-16 17:40:46 -0700153 return;
154 }
155
156 // Dump the most recent N entries.
157 const size_t kLast = 10;
Elliott Hughes6c1a3942011-08-17 15:00:06 -0700158 size_t count = entries.size();
Elliott Hughes11e45072011-08-16 17:40:46 -0700159 int first = count - kLast;
160 if (first < 0) {
161 first = 0;
162 }
Elliott Hughes73e66f72012-05-09 09:34:45 -0700163 os << " Last " << (count - first) << " entries (of " << count << "):\n";
Mathieu Chartier38ebea42014-12-08 11:50:36 -0800164 Runtime* runtime = Runtime::Current();
Elliott Hughes11e45072011-08-16 17:40:46 -0700165 for (int idx = count - 1; idx >= first; --idx) {
Mathieu Chartier4099b782014-12-08 12:59:27 -0800166 mirror::Object* ref = entries[idx].Read();
Mathieu Chartier38ebea42014-12-08 11:50:36 -0800167 if (ref == nullptr) {
Elliott Hughes11e45072011-08-16 17:40:46 -0700168 continue;
169 }
Mathieu Chartier38ebea42014-12-08 11:50:36 -0800170 if (runtime->IsClearedJniWeakGlobal(ref)) {
Elliott Hughes73e66f72012-05-09 09:34:45 -0700171 os << StringPrintf(" %5d: cleared jweak\n", idx);
Elliott Hughes11e45072011-08-16 17:40:46 -0700172 continue;
173 }
Mathieu Chartier38ebea42014-12-08 11:50:36 -0800174 if (ref->GetClass() == nullptr) {
Elliott Hughes11e45072011-08-16 17:40:46 -0700175 // should only be possible right after a plain dvmMalloc().
176 size_t size = ref->SizeOf();
Elliott Hughes73e66f72012-05-09 09:34:45 -0700177 os << StringPrintf(" %5d: %p (raw) (%zd bytes)\n", idx, ref, size);
Elliott Hughes11e45072011-08-16 17:40:46 -0700178 continue;
179 }
180
Elliott Hughes54e7df12011-09-16 11:47:04 -0700181 std::string className(PrettyTypeOf(ref));
Elliott Hughes11e45072011-08-16 17:40:46 -0700182
183 std::string extras;
Elliott Hughes73e66f72012-05-09 09:34:45 -0700184 size_t element_count = GetElementCount(ref);
185 if (element_count != 0) {
186 StringAppendF(&extras, " (%zd elements)", element_count);
187 } else if (ref->GetClass()->IsStringClass()) {
Mathieu Chartier38ebea42014-12-08 11:50:36 -0800188 mirror::String* s = ref->AsString();
Elliott Hughes73e66f72012-05-09 09:34:45 -0700189 std::string utf8(s->ToModifiedUtf8());
190 if (s->GetLength() <= 16) {
191 StringAppendF(&extras, " \"%s\"", utf8.c_str());
Elliott Hughes11e45072011-08-16 17:40:46 -0700192 } else {
Elliott Hughes73e66f72012-05-09 09:34:45 -0700193 StringAppendF(&extras, " \"%.16s... (%d chars)", utf8.c_str(), s->GetLength());
Elliott Hughes11e45072011-08-16 17:40:46 -0700194 }
Elliott Hughes11e45072011-08-16 17:40:46 -0700195 }
Elliott Hughes73e66f72012-05-09 09:34:45 -0700196 os << StringPrintf(" %5d: ", idx) << ref << " " << className << extras << "\n";
Elliott Hughes11e45072011-08-16 17:40:46 -0700197 }
198
Mathieu Chartier38ebea42014-12-08 11:50:36 -0800199 // Make a copy of the table and sort it, only adding non null and not cleared elements.
Hiroshi Yamauchiea2e1bd2014-06-18 13:47:35 -0700200 Table sorted_entries;
Mathieu Chartier38ebea42014-12-08 11:50:36 -0800201 for (GcRoot<mirror::Object>& root : entries) {
Mathieu Chartier4099b782014-12-08 12:59:27 -0800202 if (!root.IsNull() && !runtime->IsClearedJniWeakGlobal(root.Read())) {
Mathieu Chartier38ebea42014-12-08 11:50:36 -0800203 sorted_entries.push_back(root);
204 }
Elliott Hughes11e45072011-08-16 17:40:46 -0700205 }
206 if (sorted_entries.empty()) {
207 return;
208 }
Mathieu Chartier4c4d6092015-01-22 17:02:27 -0800209 std::sort(sorted_entries.begin(), sorted_entries.end(), GcRootComparator());
Elliott Hughes11e45072011-08-16 17:40:46 -0700210
211 // Dump a summary of the whole table.
Elliott Hughes73e66f72012-05-09 09:34:45 -0700212 os << " Summary:\n";
Elliott Hughes11e45072011-08-16 17:40:46 -0700213 size_t equiv = 0;
214 size_t identical = 0;
Mathieu Chartier38ebea42014-12-08 11:50:36 -0800215 mirror::Object* prev = nullptr;
216 for (GcRoot<mirror::Object>& root : sorted_entries) {
217 mirror::Object* current = root.Read<kWithoutReadBarrier>();
218 if (prev != nullptr) {
219 const size_t element_count = GetElementCount(prev);
220 if (current == prev) {
221 // Same reference, added more than once.
222 ++identical;
223 } else if (current->GetClass() == prev->GetClass() &&
224 GetElementCount(current) == element_count) {
225 // Same class / element count, different object.
226 ++equiv;
227 } else {
228 // Different class.
229 DumpSummaryLine(os, prev, element_count, identical, equiv);
230 equiv = 0;
231 identical = 0;
232 }
Elliott Hughes11e45072011-08-16 17:40:46 -0700233 }
Mathieu Chartier38ebea42014-12-08 11:50:36 -0800234 prev = current;
Elliott Hughes11e45072011-08-16 17:40:46 -0700235 }
236 // Handle the last entry.
Mathieu Chartier38ebea42014-12-08 11:50:36 -0800237 DumpSummaryLine(os, prev, GetElementCount(prev), identical, equiv);
Elliott Hughes11e45072011-08-16 17:40:46 -0700238}
239
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -0700240void ReferenceTable::VisitRoots(RootVisitor* visitor, const RootInfo& root_info) {
Mathieu Chartier4809d0a2015-04-07 10:39:04 -0700241 BufferedRootVisitor<kDefaultBufferedRootCount> buffered_visitor(visitor, root_info);
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700242 for (GcRoot<mirror::Object>& root : entries_) {
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -0700243 buffered_visitor.VisitRoot(root);
Elliott Hughes410c0c82011-09-01 17:58:25 -0700244 }
245}
246
Elliott Hughes11e45072011-08-16 17:40:46 -0700247} // namespace art