blob: 01c5070869bf78248faf993f530553eb7b3c2e1e [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) {
Elliott Hughes11e45072011-08-16 17:40:46 -070043 DCHECK(obj != NULL);
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.
Ian Rogersef7d42f2014-01-06 12:55:46 -080065static size_t GetElementCount(mirror::Object* obj) SHARED_LOCKS_REQUIRED(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
74struct ObjectComparator {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -070075 bool operator()(GcRoot<mirror::Object> root1, GcRoot<mirror::Object> root2)
Ian Rogers00f7d0e2012-07-19 15:28:27 -070076 // TODO: enable analysis when analysis can work with the STL.
77 NO_THREAD_SAFETY_ANALYSIS {
Ian Rogers81d425b2012-09-27 16:03:43 -070078 Locks::mutator_lock_->AssertSharedHeld(Thread::Current());
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -070079 mirror::Object* obj1 = root1.Read<kWithoutReadBarrier>();
80 mirror::Object* obj2 = root2.Read<kWithoutReadBarrier>();
Elliott Hughes11e45072011-08-16 17:40:46 -070081 // Ensure null references and cleared jweaks appear at the end.
82 if (obj1 == NULL) {
83 return true;
84 } else if (obj2 == NULL) {
85 return false;
86 }
Ian Rogersc0542af2014-09-03 16:16:56 -070087 Runtime* runtime = Runtime::Current();
88 if (runtime->IsClearedJniWeakGlobal(obj1)) {
Elliott Hughes11e45072011-08-16 17:40:46 -070089 return true;
Ian Rogersc0542af2014-09-03 16:16:56 -070090 } else if (runtime->IsClearedJniWeakGlobal(obj2)) {
Elliott Hughes11e45072011-08-16 17:40:46 -070091 return false;
92 }
93
94 // Sort by class...
95 if (obj1->GetClass() != obj2->GetClass()) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -070096 return obj1->GetClass()->IdentityHashCode() < obj2->IdentityHashCode();
Elliott Hughes11e45072011-08-16 17:40:46 -070097 } else {
98 // ...then by size...
99 size_t count1 = obj1->SizeOf();
100 size_t count2 = obj2->SizeOf();
101 if (count1 != count2) {
102 return count1 < count2;
103 } else {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700104 // ...and finally by identity hash code.
105 return obj1->IdentityHashCode() < obj2->IdentityHashCode();
Elliott Hughes11e45072011-08-16 17:40:46 -0700106 }
107 }
108 }
109};
110
Carl Shapiro5b1982d2011-08-16 18:35:19 -0700111// Log an object with some additional info.
112//
113// Pass in the number of elements in the array (or 0 if this is not an
114// array object), and the number of additional objects that are identical
115// or equivalent to the original.
Ian Rogersef7d42f2014-01-06 12:55:46 -0800116static void DumpSummaryLine(std::ostream& os, mirror::Object* obj, size_t element_count,
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700117 int identical, int equiv)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700118 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes11e45072011-08-16 17:40:46 -0700119 if (obj == NULL) {
Elliott Hughes73e66f72012-05-09 09:34:45 -0700120 os << " NULL reference (count=" << equiv << ")\n";
Elliott Hughes11e45072011-08-16 17:40:46 -0700121 return;
122 }
Ian Rogersc0542af2014-09-03 16:16:56 -0700123 if (Runtime::Current()->IsClearedJniWeakGlobal(obj)) {
Elliott Hughes73e66f72012-05-09 09:34:45 -0700124 os << " cleared jweak (count=" << equiv << ")\n";
Elliott Hughes11e45072011-08-16 17:40:46 -0700125 return;
126 }
127
Elliott Hughes54e7df12011-09-16 11:47:04 -0700128 std::string className(PrettyTypeOf(obj));
Elliott Hughes11e45072011-08-16 17:40:46 -0700129 if (obj->IsClass()) {
130 // We're summarizing multiple instances, so using the exemplar
131 // Class' type parameter here would be misleading.
132 className = "java.lang.Class";
133 }
Elliott Hughes73e66f72012-05-09 09:34:45 -0700134 if (element_count != 0) {
135 StringAppendF(&className, " (%zd elements)", element_count);
Elliott Hughes11e45072011-08-16 17:40:46 -0700136 }
137
138 size_t total = identical + equiv + 1;
Elliott Hughes215f3142012-01-19 00:22:47 -0800139 std::string msg(StringPrintf("%5zd of %s", total, className.c_str()));
Elliott Hughes11e45072011-08-16 17:40:46 -0700140 if (identical + equiv != 0) {
141 StringAppendF(&msg, " (%d unique instances)", equiv + 1);
142 }
Elliott Hughes73e66f72012-05-09 09:34:45 -0700143 os << " " << msg << "\n";
Elliott Hughes11e45072011-08-16 17:40:46 -0700144}
145
146size_t ReferenceTable::Size() const {
147 return entries_.size();
148}
149
Hiroshi Yamauchiea2e1bd2014-06-18 13:47:35 -0700150void ReferenceTable::Dump(std::ostream& os) {
Elliott Hughes73e66f72012-05-09 09:34:45 -0700151 os << name_ << " reference table dump:\n";
152 Dump(os, entries_);
Elliott Hughes6c1a3942011-08-17 15:00:06 -0700153}
Elliott Hughes11e45072011-08-16 17:40:46 -0700154
Hiroshi Yamauchiea2e1bd2014-06-18 13:47:35 -0700155void ReferenceTable::Dump(std::ostream& os, Table& entries) {
Elliott Hughes6c1a3942011-08-17 15:00:06 -0700156 if (entries.empty()) {
Elliott Hughes73e66f72012-05-09 09:34:45 -0700157 os << " (empty)\n";
Elliott Hughes11e45072011-08-16 17:40:46 -0700158 return;
159 }
160
161 // Dump the most recent N entries.
162 const size_t kLast = 10;
Elliott Hughes6c1a3942011-08-17 15:00:06 -0700163 size_t count = entries.size();
Elliott Hughes11e45072011-08-16 17:40:46 -0700164 int first = count - kLast;
165 if (first < 0) {
166 first = 0;
167 }
Elliott Hughes73e66f72012-05-09 09:34:45 -0700168 os << " Last " << (count - first) << " entries (of " << count << "):\n";
Elliott Hughes11e45072011-08-16 17:40:46 -0700169 for (int idx = count - 1; idx >= first; --idx) {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700170 mirror::Object* ref = entries[idx].Read();
Elliott Hughes11e45072011-08-16 17:40:46 -0700171 if (ref == NULL) {
172 continue;
173 }
Ian Rogersc0542af2014-09-03 16:16:56 -0700174 if (Runtime::Current()->IsClearedJniWeakGlobal(ref)) {
Elliott Hughes73e66f72012-05-09 09:34:45 -0700175 os << StringPrintf(" %5d: cleared jweak\n", idx);
Elliott Hughes11e45072011-08-16 17:40:46 -0700176 continue;
177 }
178 if (ref->GetClass() == NULL) {
179 // should only be possible right after a plain dvmMalloc().
180 size_t size = ref->SizeOf();
Elliott Hughes73e66f72012-05-09 09:34:45 -0700181 os << StringPrintf(" %5d: %p (raw) (%zd bytes)\n", idx, ref, size);
Elliott Hughes11e45072011-08-16 17:40:46 -0700182 continue;
183 }
184
Elliott Hughes54e7df12011-09-16 11:47:04 -0700185 std::string className(PrettyTypeOf(ref));
Elliott Hughes11e45072011-08-16 17:40:46 -0700186
187 std::string extras;
Elliott Hughes73e66f72012-05-09 09:34:45 -0700188 size_t element_count = GetElementCount(ref);
189 if (element_count != 0) {
190 StringAppendF(&extras, " (%zd elements)", element_count);
191 } else if (ref->GetClass()->IsStringClass()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800192 mirror::String* s = const_cast<mirror::Object*>(ref)->AsString();
Elliott Hughes73e66f72012-05-09 09:34:45 -0700193 std::string utf8(s->ToModifiedUtf8());
194 if (s->GetLength() <= 16) {
195 StringAppendF(&extras, " \"%s\"", utf8.c_str());
Elliott Hughes11e45072011-08-16 17:40:46 -0700196 } else {
Elliott Hughes73e66f72012-05-09 09:34:45 -0700197 StringAppendF(&extras, " \"%.16s... (%d chars)", utf8.c_str(), s->GetLength());
Elliott Hughes11e45072011-08-16 17:40:46 -0700198 }
Elliott Hughes11e45072011-08-16 17:40:46 -0700199 }
Elliott Hughes73e66f72012-05-09 09:34:45 -0700200 os << StringPrintf(" %5d: ", idx) << ref << " " << className << extras << "\n";
Elliott Hughes11e45072011-08-16 17:40:46 -0700201 }
202
203 // Make a copy of the table and sort it.
Hiroshi Yamauchiea2e1bd2014-06-18 13:47:35 -0700204 Table sorted_entries;
205 for (size_t i = 0; i < entries.size(); ++i) {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700206 mirror::Object* entry = entries[i].Read();
207 sorted_entries.push_back(GcRoot<mirror::Object>(entry));
Hiroshi Yamauchiea2e1bd2014-06-18 13:47:35 -0700208 }
Elliott Hughes11e45072011-08-16 17:40:46 -0700209 std::sort(sorted_entries.begin(), sorted_entries.end(), ObjectComparator());
210
211 // Remove any uninteresting stuff from the list. The sort moved them all to the end.
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700212 while (!sorted_entries.empty() && sorted_entries.back().IsNull()) {
Elliott Hughes11e45072011-08-16 17:40:46 -0700213 sorted_entries.pop_back();
214 }
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700215 while (!sorted_entries.empty() &&
Ian Rogersc0542af2014-09-03 16:16:56 -0700216 Runtime::Current()->IsClearedJniWeakGlobal(
217 sorted_entries.back().Read<kWithoutReadBarrier>())) {
Elliott Hughes11e45072011-08-16 17:40:46 -0700218 sorted_entries.pop_back();
219 }
220 if (sorted_entries.empty()) {
221 return;
222 }
223
224 // Dump a summary of the whole table.
Elliott Hughes73e66f72012-05-09 09:34:45 -0700225 os << " Summary:\n";
Elliott Hughes11e45072011-08-16 17:40:46 -0700226 size_t equiv = 0;
227 size_t identical = 0;
228 for (size_t idx = 1; idx < count; idx++) {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700229 mirror::Object* prev = sorted_entries[idx-1].Read<kWithoutReadBarrier>();
230 mirror::Object* current = sorted_entries[idx].Read<kWithoutReadBarrier>();
Elliott Hughes73e66f72012-05-09 09:34:45 -0700231 size_t element_count = GetElementCount(prev);
Elliott Hughes11e45072011-08-16 17:40:46 -0700232 if (current == prev) {
233 // Same reference, added more than once.
234 identical++;
Elliott Hughes73e66f72012-05-09 09:34:45 -0700235 } else if (current->GetClass() == prev->GetClass() && GetElementCount(current) == element_count) {
Elliott Hughes11e45072011-08-16 17:40:46 -0700236 // Same class / element count, different object.
237 equiv++;
238 } else {
239 // Different class.
Elliott Hughes73e66f72012-05-09 09:34:45 -0700240 DumpSummaryLine(os, prev, element_count, identical, equiv);
Elliott Hughes11e45072011-08-16 17:40:46 -0700241 equiv = identical = 0;
242 }
243 }
244 // Handle the last entry.
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700245 DumpSummaryLine(os, sorted_entries.back().Read<kWithoutReadBarrier>(),
246 GetElementCount(sorted_entries.back().Read<kWithoutReadBarrier>()),
247 identical, equiv);
Elliott Hughes11e45072011-08-16 17:40:46 -0700248}
249
Mathieu Chartier83c8ee02014-01-28 14:50:23 -0800250void ReferenceTable::VisitRoots(RootCallback* visitor, void* arg, uint32_t tid,
251 RootType root_type) {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700252 for (GcRoot<mirror::Object>& root : entries_) {
253 root.VisitRoot(visitor, arg, tid, root_type);
Elliott Hughes410c0c82011-09-01 17:58:25 -0700254 }
255}
256
Elliott Hughes11e45072011-08-16 17:40:46 -0700257} // namespace art