reference_table.cc revision 81d425b0b232962441616f8b14f73620bffef5e5
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 19#include "indirect_reference_table.h" 20#include "mutex.h" 21 22#include "object.h" 23 24namespace art { 25 26ReferenceTable::ReferenceTable(const char* name, size_t initial_size, size_t max_size) 27 : name_(name), max_size_(max_size) { 28 CHECK_LE(initial_size, max_size); 29 entries_.reserve(initial_size); 30} 31 32ReferenceTable::~ReferenceTable() { 33} 34 35void ReferenceTable::Add(const Object* obj) { 36 DCHECK(obj != NULL); 37 if (entries_.size() == max_size_) { 38 LOG(FATAL) << "ReferenceTable '" << name_ << "' " 39 << "overflowed (" << max_size_ << " entries)"; 40 } 41 entries_.push_back(obj); 42} 43 44void ReferenceTable::Remove(const Object* obj) { 45 // We iterate backwards on the assumption that references are LIFO. 46 for (int i = entries_.size() - 1; i >= 0; --i) { 47 if (entries_[i] == obj) { 48 entries_.erase(entries_.begin() + i); 49 return; 50 } 51 } 52} 53 54// If "obj" is an array, return the number of elements in the array. 55// Otherwise, return zero. 56static size_t GetElementCount(const Object* obj) { 57 if (obj == NULL || obj == kClearedJniWeakGlobal || !obj->IsArrayInstance()) { 58 return 0; 59 } 60 return obj->AsArray()->GetLength(); 61} 62 63struct ObjectComparator { 64 bool operator()(const Object* obj1, const Object* obj2) 65 // TODO: enable analysis when analysis can work with the STL. 66 NO_THREAD_SAFETY_ANALYSIS { 67 Locks::mutator_lock_->AssertSharedHeld(Thread::Current()); 68 // Ensure null references and cleared jweaks appear at the end. 69 if (obj1 == NULL) { 70 return true; 71 } else if (obj2 == NULL) { 72 return false; 73 } 74 if (obj1 == kClearedJniWeakGlobal) { 75 return true; 76 } else if (obj2 == kClearedJniWeakGlobal) { 77 return false; 78 } 79 80 // Sort by class... 81 if (obj1->GetClass() != obj2->GetClass()) { 82 return obj1->GetClass()->IdentityHashCode() < obj2->IdentityHashCode(); 83 } else { 84 // ...then by size... 85 size_t count1 = obj1->SizeOf(); 86 size_t count2 = obj2->SizeOf(); 87 if (count1 != count2) { 88 return count1 < count2; 89 } else { 90 // ...and finally by identity hash code. 91 return obj1->IdentityHashCode() < obj2->IdentityHashCode(); 92 } 93 } 94 } 95}; 96 97// Log an object with some additional info. 98// 99// Pass in the number of elements in the array (or 0 if this is not an 100// array object), and the number of additional objects that are identical 101// or equivalent to the original. 102static void DumpSummaryLine(std::ostream& os, const Object* obj, size_t element_count, 103 int identical, int equiv) 104 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 105 if (obj == NULL) { 106 os << " NULL reference (count=" << equiv << ")\n"; 107 return; 108 } 109 if (obj == kClearedJniWeakGlobal) { 110 os << " cleared jweak (count=" << equiv << ")\n"; 111 return; 112 } 113 114 std::string className(PrettyTypeOf(obj)); 115 if (obj->IsClass()) { 116 // We're summarizing multiple instances, so using the exemplar 117 // Class' type parameter here would be misleading. 118 className = "java.lang.Class"; 119 } 120 if (element_count != 0) { 121 StringAppendF(&className, " (%zd elements)", element_count); 122 } 123 124 size_t total = identical + equiv + 1; 125 std::string msg(StringPrintf("%5zd of %s", total, className.c_str())); 126 if (identical + equiv != 0) { 127 StringAppendF(&msg, " (%d unique instances)", equiv + 1); 128 } 129 os << " " << msg << "\n"; 130} 131 132size_t ReferenceTable::Size() const { 133 return entries_.size(); 134} 135 136void ReferenceTable::Dump(std::ostream& os) const { 137 os << name_ << " reference table dump:\n"; 138 Dump(os, entries_); 139} 140 141void ReferenceTable::Dump(std::ostream& os, const Table& entries) { 142 if (entries.empty()) { 143 os << " (empty)\n"; 144 return; 145 } 146 147 // Dump the most recent N entries. 148 const size_t kLast = 10; 149 size_t count = entries.size(); 150 int first = count - kLast; 151 if (first < 0) { 152 first = 0; 153 } 154 os << " Last " << (count - first) << " entries (of " << count << "):\n"; 155 for (int idx = count - 1; idx >= first; --idx) { 156 const Object* ref = entries[idx]; 157 if (ref == NULL) { 158 continue; 159 } 160 if (ref == kClearedJniWeakGlobal) { 161 os << StringPrintf(" %5d: cleared jweak\n", idx); 162 continue; 163 } 164 if (ref->GetClass() == NULL) { 165 // should only be possible right after a plain dvmMalloc(). 166 size_t size = ref->SizeOf(); 167 os << StringPrintf(" %5d: %p (raw) (%zd bytes)\n", idx, ref, size); 168 continue; 169 } 170 171 std::string className(PrettyTypeOf(ref)); 172 173 std::string extras; 174 size_t element_count = GetElementCount(ref); 175 if (element_count != 0) { 176 StringAppendF(&extras, " (%zd elements)", element_count); 177 } else if (ref->GetClass()->IsStringClass()) { 178 String* s = const_cast<Object*>(ref)->AsString(); 179 std::string utf8(s->ToModifiedUtf8()); 180 if (s->GetLength() <= 16) { 181 StringAppendF(&extras, " \"%s\"", utf8.c_str()); 182 } else { 183 StringAppendF(&extras, " \"%.16s... (%d chars)", utf8.c_str(), s->GetLength()); 184 } 185 } 186 os << StringPrintf(" %5d: ", idx) << ref << " " << className << extras << "\n"; 187 } 188 189 // Make a copy of the table and sort it. 190 Table sorted_entries(entries.begin(), entries.end()); 191 std::sort(sorted_entries.begin(), sorted_entries.end(), ObjectComparator()); 192 193 // Remove any uninteresting stuff from the list. The sort moved them all to the end. 194 while (!sorted_entries.empty() && sorted_entries.back() == NULL) { 195 sorted_entries.pop_back(); 196 } 197 while (!sorted_entries.empty() && sorted_entries.back() == kClearedJniWeakGlobal) { 198 sorted_entries.pop_back(); 199 } 200 if (sorted_entries.empty()) { 201 return; 202 } 203 204 // Dump a summary of the whole table. 205 os << " Summary:\n"; 206 size_t equiv = 0; 207 size_t identical = 0; 208 for (size_t idx = 1; idx < count; idx++) { 209 const Object* prev = sorted_entries[idx-1]; 210 const Object* current = sorted_entries[idx]; 211 size_t element_count = GetElementCount(prev); 212 if (current == prev) { 213 // Same reference, added more than once. 214 identical++; 215 } else if (current->GetClass() == prev->GetClass() && GetElementCount(current) == element_count) { 216 // Same class / element count, different object. 217 equiv++; 218 } else { 219 // Different class. 220 DumpSummaryLine(os, prev, element_count, identical, equiv); 221 equiv = identical = 0; 222 } 223 } 224 // Handle the last entry. 225 DumpSummaryLine(os, sorted_entries.back(), GetElementCount(sorted_entries.back()), identical, equiv); 226} 227 228void ReferenceTable::VisitRoots(Heap::RootVisitor* visitor, void* arg) { 229 typedef Table::const_iterator It; // TODO: C++0x auto 230 for (It it = entries_.begin(), end = entries_.end(); it != end; ++it) { 231 visitor(*it, arg); 232 } 233} 234 235} // namespace art 236