Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 1 | /* |
| 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 Hughes | 76b6167 | 2012-12-12 17:47:30 -0800 | [diff] [blame] | 19 | #include "base/mutex.h" |
Elliott Hughes | 6c1a394 | 2011-08-17 15:00:06 -0700 | [diff] [blame] | 20 | #include "indirect_reference_table.h" |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 21 | #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 Rogers | b0fa5dc | 2014-04-28 16:47:08 -0700 | [diff] [blame] | 26 | #include "mirror/string-inl.h" |
Ian Rogers | c0542af | 2014-09-03 16:16:56 -0700 | [diff] [blame] | 27 | #include "runtime-inl.h" |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 28 | #include "thread.h" |
| 29 | #include "utils.h" |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 30 | |
| 31 | namespace art { |
| 32 | |
Elliott Hughes | bb1e8f0 | 2011-10-18 14:14:25 -0700 | [diff] [blame] | 33 | ReferenceTable::ReferenceTable(const char* name, size_t initial_size, size_t max_size) |
| 34 | : name_(name), max_size_(max_size) { |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 35 | CHECK_LE(initial_size, max_size); |
| 36 | entries_.reserve(initial_size); |
| 37 | } |
| 38 | |
Elliott Hughes | c1674ed | 2011-08-25 18:09:09 -0700 | [diff] [blame] | 39 | ReferenceTable::~ReferenceTable() { |
| 40 | } |
| 41 | |
Mathieu Chartier | 423d2a3 | 2013-09-12 17:33:56 -0700 | [diff] [blame] | 42 | void ReferenceTable::Add(mirror::Object* obj) { |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 43 | DCHECK(obj != NULL); |
Mathieu Chartier | c645f1d | 2014-03-06 18:11:53 -0800 | [diff] [blame] | 44 | VerifyObject(obj); |
Mathieu Chartier | 423d2a3 | 2013-09-12 17:33:56 -0700 | [diff] [blame] | 45 | if (entries_.size() >= max_size_) { |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 46 | LOG(FATAL) << "ReferenceTable '" << name_ << "' " |
| 47 | << "overflowed (" << max_size_ << " entries)"; |
| 48 | } |
Hiroshi Yamauchi | 94f7b49 | 2014-07-22 18:08:23 -0700 | [diff] [blame] | 49 | entries_.push_back(GcRoot<mirror::Object>(obj)); |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 50 | } |
| 51 | |
Mathieu Chartier | 423d2a3 | 2013-09-12 17:33:56 -0700 | [diff] [blame] | 52 | void ReferenceTable::Remove(mirror::Object* obj) { |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 53 | // We iterate backwards on the assumption that references are LIFO. |
| 54 | for (int i = entries_.size() - 1; i >= 0; --i) { |
Hiroshi Yamauchi | 94f7b49 | 2014-07-22 18:08:23 -0700 | [diff] [blame] | 55 | mirror::Object* entry = entries_[i].Read(); |
Hiroshi Yamauchi | ea2e1bd | 2014-06-18 13:47:35 -0700 | [diff] [blame] | 56 | if (entry == obj) { |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 57 | entries_.erase(entries_.begin() + i); |
| 58 | return; |
| 59 | } |
| 60 | } |
| 61 | } |
| 62 | |
Carl Shapiro | 5b1982d | 2011-08-16 18:35:19 -0700 | [diff] [blame] | 63 | // If "obj" is an array, return the number of elements in the array. |
| 64 | // Otherwise, return zero. |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 65 | static size_t GetElementCount(mirror::Object* obj) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { |
Ian Rogers | c0542af | 2014-09-03 16:16:56 -0700 | [diff] [blame] | 66 | // 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 Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 69 | return 0; |
| 70 | } |
| 71 | return obj->AsArray()->GetLength(); |
| 72 | } |
| 73 | |
| 74 | struct ObjectComparator { |
Hiroshi Yamauchi | 94f7b49 | 2014-07-22 18:08:23 -0700 | [diff] [blame] | 75 | bool operator()(GcRoot<mirror::Object> root1, GcRoot<mirror::Object> root2) |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 76 | // TODO: enable analysis when analysis can work with the STL. |
| 77 | NO_THREAD_SAFETY_ANALYSIS { |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 78 | Locks::mutator_lock_->AssertSharedHeld(Thread::Current()); |
Hiroshi Yamauchi | 94f7b49 | 2014-07-22 18:08:23 -0700 | [diff] [blame] | 79 | mirror::Object* obj1 = root1.Read<kWithoutReadBarrier>(); |
| 80 | mirror::Object* obj2 = root2.Read<kWithoutReadBarrier>(); |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 81 | // 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 Rogers | c0542af | 2014-09-03 16:16:56 -0700 | [diff] [blame] | 87 | Runtime* runtime = Runtime::Current(); |
| 88 | if (runtime->IsClearedJniWeakGlobal(obj1)) { |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 89 | return true; |
Ian Rogers | c0542af | 2014-09-03 16:16:56 -0700 | [diff] [blame] | 90 | } else if (runtime->IsClearedJniWeakGlobal(obj2)) { |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 91 | return false; |
| 92 | } |
| 93 | |
| 94 | // Sort by class... |
| 95 | if (obj1->GetClass() != obj2->GetClass()) { |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 96 | return obj1->GetClass()->IdentityHashCode() < obj2->IdentityHashCode(); |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 97 | } 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 Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 104 | // ...and finally by identity hash code. |
| 105 | return obj1->IdentityHashCode() < obj2->IdentityHashCode(); |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 106 | } |
| 107 | } |
| 108 | } |
| 109 | }; |
| 110 | |
Carl Shapiro | 5b1982d | 2011-08-16 18:35:19 -0700 | [diff] [blame] | 111 | // 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 Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 116 | static void DumpSummaryLine(std::ostream& os, mirror::Object* obj, size_t element_count, |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 117 | int identical, int equiv) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 118 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 119 | if (obj == NULL) { |
Elliott Hughes | 73e66f7 | 2012-05-09 09:34:45 -0700 | [diff] [blame] | 120 | os << " NULL reference (count=" << equiv << ")\n"; |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 121 | return; |
| 122 | } |
Ian Rogers | c0542af | 2014-09-03 16:16:56 -0700 | [diff] [blame] | 123 | if (Runtime::Current()->IsClearedJniWeakGlobal(obj)) { |
Elliott Hughes | 73e66f7 | 2012-05-09 09:34:45 -0700 | [diff] [blame] | 124 | os << " cleared jweak (count=" << equiv << ")\n"; |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 125 | return; |
| 126 | } |
| 127 | |
Elliott Hughes | 54e7df1 | 2011-09-16 11:47:04 -0700 | [diff] [blame] | 128 | std::string className(PrettyTypeOf(obj)); |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 129 | 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 Hughes | 73e66f7 | 2012-05-09 09:34:45 -0700 | [diff] [blame] | 134 | if (element_count != 0) { |
| 135 | StringAppendF(&className, " (%zd elements)", element_count); |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 136 | } |
| 137 | |
| 138 | size_t total = identical + equiv + 1; |
Elliott Hughes | 215f314 | 2012-01-19 00:22:47 -0800 | [diff] [blame] | 139 | std::string msg(StringPrintf("%5zd of %s", total, className.c_str())); |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 140 | if (identical + equiv != 0) { |
| 141 | StringAppendF(&msg, " (%d unique instances)", equiv + 1); |
| 142 | } |
Elliott Hughes | 73e66f7 | 2012-05-09 09:34:45 -0700 | [diff] [blame] | 143 | os << " " << msg << "\n"; |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 144 | } |
| 145 | |
| 146 | size_t ReferenceTable::Size() const { |
| 147 | return entries_.size(); |
| 148 | } |
| 149 | |
Hiroshi Yamauchi | ea2e1bd | 2014-06-18 13:47:35 -0700 | [diff] [blame] | 150 | void ReferenceTable::Dump(std::ostream& os) { |
Elliott Hughes | 73e66f7 | 2012-05-09 09:34:45 -0700 | [diff] [blame] | 151 | os << name_ << " reference table dump:\n"; |
| 152 | Dump(os, entries_); |
Elliott Hughes | 6c1a394 | 2011-08-17 15:00:06 -0700 | [diff] [blame] | 153 | } |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 154 | |
Hiroshi Yamauchi | ea2e1bd | 2014-06-18 13:47:35 -0700 | [diff] [blame] | 155 | void ReferenceTable::Dump(std::ostream& os, Table& entries) { |
Elliott Hughes | 6c1a394 | 2011-08-17 15:00:06 -0700 | [diff] [blame] | 156 | if (entries.empty()) { |
Elliott Hughes | 73e66f7 | 2012-05-09 09:34:45 -0700 | [diff] [blame] | 157 | os << " (empty)\n"; |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 158 | return; |
| 159 | } |
| 160 | |
| 161 | // Dump the most recent N entries. |
| 162 | const size_t kLast = 10; |
Elliott Hughes | 6c1a394 | 2011-08-17 15:00:06 -0700 | [diff] [blame] | 163 | size_t count = entries.size(); |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 164 | int first = count - kLast; |
| 165 | if (first < 0) { |
| 166 | first = 0; |
| 167 | } |
Elliott Hughes | 73e66f7 | 2012-05-09 09:34:45 -0700 | [diff] [blame] | 168 | os << " Last " << (count - first) << " entries (of " << count << "):\n"; |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 169 | for (int idx = count - 1; idx >= first; --idx) { |
Hiroshi Yamauchi | 94f7b49 | 2014-07-22 18:08:23 -0700 | [diff] [blame] | 170 | mirror::Object* ref = entries[idx].Read(); |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 171 | if (ref == NULL) { |
| 172 | continue; |
| 173 | } |
Ian Rogers | c0542af | 2014-09-03 16:16:56 -0700 | [diff] [blame] | 174 | if (Runtime::Current()->IsClearedJniWeakGlobal(ref)) { |
Elliott Hughes | 73e66f7 | 2012-05-09 09:34:45 -0700 | [diff] [blame] | 175 | os << StringPrintf(" %5d: cleared jweak\n", idx); |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 176 | continue; |
| 177 | } |
| 178 | if (ref->GetClass() == NULL) { |
| 179 | // should only be possible right after a plain dvmMalloc(). |
| 180 | size_t size = ref->SizeOf(); |
Elliott Hughes | 73e66f7 | 2012-05-09 09:34:45 -0700 | [diff] [blame] | 181 | os << StringPrintf(" %5d: %p (raw) (%zd bytes)\n", idx, ref, size); |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 182 | continue; |
| 183 | } |
| 184 | |
Elliott Hughes | 54e7df1 | 2011-09-16 11:47:04 -0700 | [diff] [blame] | 185 | std::string className(PrettyTypeOf(ref)); |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 186 | |
| 187 | std::string extras; |
Elliott Hughes | 73e66f7 | 2012-05-09 09:34:45 -0700 | [diff] [blame] | 188 | 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 Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 192 | mirror::String* s = const_cast<mirror::Object*>(ref)->AsString(); |
Elliott Hughes | 73e66f7 | 2012-05-09 09:34:45 -0700 | [diff] [blame] | 193 | std::string utf8(s->ToModifiedUtf8()); |
| 194 | if (s->GetLength() <= 16) { |
| 195 | StringAppendF(&extras, " \"%s\"", utf8.c_str()); |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 196 | } else { |
Elliott Hughes | 73e66f7 | 2012-05-09 09:34:45 -0700 | [diff] [blame] | 197 | StringAppendF(&extras, " \"%.16s... (%d chars)", utf8.c_str(), s->GetLength()); |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 198 | } |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 199 | } |
Elliott Hughes | 73e66f7 | 2012-05-09 09:34:45 -0700 | [diff] [blame] | 200 | os << StringPrintf(" %5d: ", idx) << ref << " " << className << extras << "\n"; |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 201 | } |
| 202 | |
| 203 | // Make a copy of the table and sort it. |
Hiroshi Yamauchi | ea2e1bd | 2014-06-18 13:47:35 -0700 | [diff] [blame] | 204 | Table sorted_entries; |
| 205 | for (size_t i = 0; i < entries.size(); ++i) { |
Hiroshi Yamauchi | 94f7b49 | 2014-07-22 18:08:23 -0700 | [diff] [blame] | 206 | mirror::Object* entry = entries[i].Read(); |
| 207 | sorted_entries.push_back(GcRoot<mirror::Object>(entry)); |
Hiroshi Yamauchi | ea2e1bd | 2014-06-18 13:47:35 -0700 | [diff] [blame] | 208 | } |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 209 | 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 Yamauchi | 94f7b49 | 2014-07-22 18:08:23 -0700 | [diff] [blame] | 212 | while (!sorted_entries.empty() && sorted_entries.back().IsNull()) { |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 213 | sorted_entries.pop_back(); |
| 214 | } |
Hiroshi Yamauchi | 94f7b49 | 2014-07-22 18:08:23 -0700 | [diff] [blame] | 215 | while (!sorted_entries.empty() && |
Ian Rogers | c0542af | 2014-09-03 16:16:56 -0700 | [diff] [blame] | 216 | Runtime::Current()->IsClearedJniWeakGlobal( |
| 217 | sorted_entries.back().Read<kWithoutReadBarrier>())) { |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 218 | sorted_entries.pop_back(); |
| 219 | } |
| 220 | if (sorted_entries.empty()) { |
| 221 | return; |
| 222 | } |
| 223 | |
| 224 | // Dump a summary of the whole table. |
Elliott Hughes | 73e66f7 | 2012-05-09 09:34:45 -0700 | [diff] [blame] | 225 | os << " Summary:\n"; |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 226 | size_t equiv = 0; |
| 227 | size_t identical = 0; |
| 228 | for (size_t idx = 1; idx < count; idx++) { |
Hiroshi Yamauchi | 94f7b49 | 2014-07-22 18:08:23 -0700 | [diff] [blame] | 229 | mirror::Object* prev = sorted_entries[idx-1].Read<kWithoutReadBarrier>(); |
| 230 | mirror::Object* current = sorted_entries[idx].Read<kWithoutReadBarrier>(); |
Elliott Hughes | 73e66f7 | 2012-05-09 09:34:45 -0700 | [diff] [blame] | 231 | size_t element_count = GetElementCount(prev); |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 232 | if (current == prev) { |
| 233 | // Same reference, added more than once. |
| 234 | identical++; |
Elliott Hughes | 73e66f7 | 2012-05-09 09:34:45 -0700 | [diff] [blame] | 235 | } else if (current->GetClass() == prev->GetClass() && GetElementCount(current) == element_count) { |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 236 | // Same class / element count, different object. |
| 237 | equiv++; |
| 238 | } else { |
| 239 | // Different class. |
Elliott Hughes | 73e66f7 | 2012-05-09 09:34:45 -0700 | [diff] [blame] | 240 | DumpSummaryLine(os, prev, element_count, identical, equiv); |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 241 | equiv = identical = 0; |
| 242 | } |
| 243 | } |
| 244 | // Handle the last entry. |
Hiroshi Yamauchi | 94f7b49 | 2014-07-22 18:08:23 -0700 | [diff] [blame] | 245 | DumpSummaryLine(os, sorted_entries.back().Read<kWithoutReadBarrier>(), |
| 246 | GetElementCount(sorted_entries.back().Read<kWithoutReadBarrier>()), |
| 247 | identical, equiv); |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 248 | } |
| 249 | |
Mathieu Chartier | 83c8ee0 | 2014-01-28 14:50:23 -0800 | [diff] [blame] | 250 | void ReferenceTable::VisitRoots(RootCallback* visitor, void* arg, uint32_t tid, |
| 251 | RootType root_type) { |
Hiroshi Yamauchi | 94f7b49 | 2014-07-22 18:08:23 -0700 | [diff] [blame] | 252 | for (GcRoot<mirror::Object>& root : entries_) { |
| 253 | root.VisitRoot(visitor, arg, tid, root_type); |
Elliott Hughes | 410c0c8 | 2011-09-01 17:58:25 -0700 | [diff] [blame] | 254 | } |
| 255 | } |
| 256 | |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 257 | } // namespace art |