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 /* 18 * Preparation and completion of hprof data generation. The output is 19 * written into two files and then combined. This is necessary because 20 * we generate some of the data (strings and classes) while we dump the 21 * heap, and some analysis tools require that the class and string data 22 * appear first. 23 */ 24 25 #include "hprof.h" 26 27 #include <errno.h> 28 #include <fcntl.h> 29 #include <stdio.h> 30 #include <string.h> 31 #include <sys/time.h> 32 #include <sys/uio.h> 33 #include <time.h> 34 #include <unistd.h> 35 36 #include <set> 37 38 #include <android-base/logging.h> 39 #include <android-base/stringprintf.h> 40 41 #include "art_field-inl.h" 42 #include "art_method-inl.h" 43 #include "base/array_ref.h" 44 #include "base/file_utils.h" 45 #include "base/macros.h" 46 #include "base/mutex.h" 47 #include "base/os.h" 48 #include "base/safe_map.h" 49 #include "base/time_utils.h" 50 #include "base/unix_file/fd_file.h" 51 #include "class_linker.h" 52 #include "class_root.h" 53 #include "common_throws.h" 54 #include "debugger.h" 55 #include "dex/dex_file-inl.h" 56 #include "gc/accounting/heap_bitmap.h" 57 #include "gc/allocation_record.h" 58 #include "gc/heap-visit-objects-inl.h" 59 #include "gc/heap.h" 60 #include "gc/scoped_gc_critical_section.h" 61 #include "gc/space/space.h" 62 #include "gc_root.h" 63 #include "jdwp/jdwp.h" 64 #include "jdwp/jdwp_priv.h" 65 #include "mirror/class-inl.h" 66 #include "mirror/class.h" 67 #include "mirror/object-refvisitor-inl.h" 68 #include "runtime_globals.h" 69 #include "scoped_thread_state_change-inl.h" 70 #include "thread_list.h" 71 72 namespace art { 73 74 namespace hprof { 75 76 static constexpr bool kDirectStream = true; 77 78 static constexpr uint32_t kHprofTime = 0; 79 static constexpr uint32_t kHprofNullThread = 0; 80 81 static constexpr size_t kMaxObjectsPerSegment = 128; 82 static constexpr size_t kMaxBytesPerSegment = 4096; 83 84 // The static field-name for the synthetic object generated to account for class static overhead. 85 static constexpr const char* kClassOverheadName = "$classOverhead"; 86 87 enum HprofTag { 88 HPROF_TAG_STRING = 0x01, 89 HPROF_TAG_LOAD_CLASS = 0x02, 90 HPROF_TAG_UNLOAD_CLASS = 0x03, 91 HPROF_TAG_STACK_FRAME = 0x04, 92 HPROF_TAG_STACK_TRACE = 0x05, 93 HPROF_TAG_ALLOC_SITES = 0x06, 94 HPROF_TAG_HEAP_SUMMARY = 0x07, 95 HPROF_TAG_START_THREAD = 0x0A, 96 HPROF_TAG_END_THREAD = 0x0B, 97 HPROF_TAG_HEAP_DUMP = 0x0C, 98 HPROF_TAG_HEAP_DUMP_SEGMENT = 0x1C, 99 HPROF_TAG_HEAP_DUMP_END = 0x2C, 100 HPROF_TAG_CPU_SAMPLES = 0x0D, 101 HPROF_TAG_CONTROL_SETTINGS = 0x0E, 102 }; 103 104 // Values for the first byte of HEAP_DUMP and HEAP_DUMP_SEGMENT records: 105 enum HprofHeapTag { 106 // Traditional. 107 HPROF_ROOT_UNKNOWN = 0xFF, 108 HPROF_ROOT_JNI_GLOBAL = 0x01, 109 HPROF_ROOT_JNI_LOCAL = 0x02, 110 HPROF_ROOT_JAVA_FRAME = 0x03, 111 HPROF_ROOT_NATIVE_STACK = 0x04, 112 HPROF_ROOT_STICKY_CLASS = 0x05, 113 HPROF_ROOT_THREAD_BLOCK = 0x06, 114 HPROF_ROOT_MONITOR_USED = 0x07, 115 HPROF_ROOT_THREAD_OBJECT = 0x08, 116 HPROF_CLASS_DUMP = 0x20, 117 HPROF_INSTANCE_DUMP = 0x21, 118 HPROF_OBJECT_ARRAY_DUMP = 0x22, 119 HPROF_PRIMITIVE_ARRAY_DUMP = 0x23, 120 121 // Android. 122 HPROF_HEAP_DUMP_INFO = 0xfe, 123 HPROF_ROOT_INTERNED_STRING = 0x89, 124 HPROF_ROOT_FINALIZING = 0x8a, // Obsolete. 125 HPROF_ROOT_DEBUGGER = 0x8b, 126 HPROF_ROOT_REFERENCE_CLEANUP = 0x8c, // Obsolete. 127 HPROF_ROOT_VM_INTERNAL = 0x8d, 128 HPROF_ROOT_JNI_MONITOR = 0x8e, 129 HPROF_UNREACHABLE = 0x90, // Obsolete. 130 HPROF_PRIMITIVE_ARRAY_NODATA_DUMP = 0xc3, // Obsolete. 131 }; 132 133 enum HprofHeapId { 134 HPROF_HEAP_DEFAULT = 0, 135 HPROF_HEAP_ZYGOTE = 'Z', 136 HPROF_HEAP_APP = 'A', 137 HPROF_HEAP_IMAGE = 'I', 138 }; 139 140 enum HprofBasicType { 141 hprof_basic_object = 2, 142 hprof_basic_boolean = 4, 143 hprof_basic_char = 5, 144 hprof_basic_float = 6, 145 hprof_basic_double = 7, 146 hprof_basic_byte = 8, 147 hprof_basic_short = 9, 148 hprof_basic_int = 10, 149 hprof_basic_long = 11, 150 }; 151 152 using HprofStringId = uint32_t; 153 using HprofClassObjectId = uint32_t; 154 using HprofClassSerialNumber = uint32_t; 155 using HprofStackTraceSerialNumber = uint32_t; 156 using HprofStackFrameId = uint32_t; 157 static constexpr HprofStackTraceSerialNumber kHprofNullStackTrace = 0; 158 159 class EndianOutput { 160 public: 161 EndianOutput() : length_(0), sum_length_(0), max_length_(0), started_(false) {} 162 virtual ~EndianOutput() {} 163 164 void StartNewRecord(uint8_t tag, uint32_t time) { 165 if (length_ > 0) { 166 EndRecord(); 167 } 168 DCHECK_EQ(length_, 0U); 169 AddU1(tag); 170 AddU4(time); 171 AddU4(0xdeaddead); // Length, replaced on flush. 172 started_ = true; 173 } 174 175 void EndRecord() { 176 // Replace length in header. 177 if (started_) { 178 UpdateU4(sizeof(uint8_t) + sizeof(uint32_t), 179 length_ - sizeof(uint8_t) - 2 * sizeof(uint32_t)); 180 } 181 182 HandleEndRecord(); 183 184 sum_length_ += length_; 185 max_length_ = std::max(max_length_, length_); 186 length_ = 0; 187 started_ = false; 188 } 189 190 void AddU1(uint8_t value) { 191 AddU1List(&value, 1); 192 } 193 void AddU2(uint16_t value) { 194 AddU2List(&value, 1); 195 } 196 void AddU4(uint32_t value) { 197 AddU4List(&value, 1); 198 } 199 200 void AddU8(uint64_t value) { 201 AddU8List(&value, 1); 202 } 203 204 void AddObjectId(const mirror::Object* value) { 205 AddU4(PointerToLowMemUInt32(value)); 206 } 207 208 void AddStackTraceSerialNumber(HprofStackTraceSerialNumber value) { 209 AddU4(value); 210 } 211 212 // The ID for the synthetic object generated to account for class static overhead. 213 void AddClassStaticsId(const mirror::Class* value) { 214 AddU4(1 | PointerToLowMemUInt32(value)); 215 } 216 217 void AddJniGlobalRefId(jobject value) { 218 AddU4(PointerToLowMemUInt32(value)); 219 } 220 221 void AddClassId(HprofClassObjectId value) { 222 AddU4(value); 223 } 224 225 void AddStringId(HprofStringId value) { 226 AddU4(value); 227 } 228 229 void AddU1List(const uint8_t* values, size_t count) { 230 HandleU1List(values, count); 231 length_ += count; 232 } 233 void AddU2List(const uint16_t* values, size_t count) { 234 HandleU2List(values, count); 235 length_ += count * sizeof(uint16_t); 236 } 237 void AddU4List(const uint32_t* values, size_t count) { 238 HandleU4List(values, count); 239 length_ += count * sizeof(uint32_t); 240 } 241 virtual void UpdateU4(size_t offset, uint32_t new_value ATTRIBUTE_UNUSED) { 242 DCHECK_LE(offset, length_ - 4); 243 } 244 void AddU8List(const uint64_t* values, size_t count) { 245 HandleU8List(values, count); 246 length_ += count * sizeof(uint64_t); 247 } 248 249 void AddIdList(mirror::ObjectArray<mirror::Object>* values) 250 REQUIRES_SHARED(Locks::mutator_lock_) { 251 const int32_t length = values->GetLength(); 252 for (int32_t i = 0; i < length; ++i) { 253 AddObjectId(values->GetWithoutChecks(i).Ptr()); 254 } 255 } 256 257 void AddUtf8String(const char* str) { 258 // The terminating NUL character is NOT written. 259 AddU1List((const uint8_t*)str, strlen(str)); 260 } 261 262 size_t Length() const { 263 return length_; 264 } 265 266 size_t SumLength() const { 267 return sum_length_; 268 } 269 270 size_t MaxLength() const { 271 return max_length_; 272 } 273 274 protected: 275 virtual void HandleU1List(const uint8_t* values ATTRIBUTE_UNUSED, 276 size_t count ATTRIBUTE_UNUSED) { 277 } 278 virtual void HandleU1AsU2List(const uint8_t* values ATTRIBUTE_UNUSED, 279 size_t count ATTRIBUTE_UNUSED) { 280 } 281 virtual void HandleU2List(const uint16_t* values ATTRIBUTE_UNUSED, 282 size_t count ATTRIBUTE_UNUSED) { 283 } 284 virtual void HandleU4List(const uint32_t* values ATTRIBUTE_UNUSED, 285 size_t count ATTRIBUTE_UNUSED) { 286 } 287 virtual void HandleU8List(const uint64_t* values ATTRIBUTE_UNUSED, 288 size_t count ATTRIBUTE_UNUSED) { 289 } 290 virtual void HandleEndRecord() { 291 } 292 293 size_t length_; // Current record size. 294 size_t sum_length_; // Size of all data. 295 size_t max_length_; // Maximum seen length. 296 bool started_; // Was StartRecord called? 297 }; 298 299 // This keeps things buffered until flushed. 300 class EndianOutputBuffered : public EndianOutput { 301 public: 302 explicit EndianOutputBuffered(size_t reserve_size) { 303 buffer_.reserve(reserve_size); 304 } 305 virtual ~EndianOutputBuffered() {} 306 307 void UpdateU4(size_t offset, uint32_t new_value) override { 308 DCHECK_LE(offset, length_ - 4); 309 buffer_[offset + 0] = static_cast<uint8_t>((new_value >> 24) & 0xFF); 310 buffer_[offset + 1] = static_cast<uint8_t>((new_value >> 16) & 0xFF); 311 buffer_[offset + 2] = static_cast<uint8_t>((new_value >> 8) & 0xFF); 312 buffer_[offset + 3] = static_cast<uint8_t>((new_value >> 0) & 0xFF); 313 } 314 315 protected: 316 void HandleU1List(const uint8_t* values, size_t count) override { 317 DCHECK_EQ(length_, buffer_.size()); 318 buffer_.insert(buffer_.end(), values, values + count); 319 } 320 321 void HandleU1AsU2List(const uint8_t* values, size_t count) override { 322 DCHECK_EQ(length_, buffer_.size()); 323 // All 8-bits are grouped in 2 to make 16-bit block like Java Char 324 if (count & 1) { 325 buffer_.push_back(0); 326 } 327 for (size_t i = 0; i < count; ++i) { 328 uint8_t value = *values; 329 buffer_.push_back(value); 330 values++; 331 } 332 } 333 334 void HandleU2List(const uint16_t* values, size_t count) override { 335 DCHECK_EQ(length_, buffer_.size()); 336 for (size_t i = 0; i < count; ++i) { 337 uint16_t value = *values; 338 buffer_.push_back(static_cast<uint8_t>((value >> 8) & 0xFF)); 339 buffer_.push_back(static_cast<uint8_t>((value >> 0) & 0xFF)); 340 values++; 341 } 342 } 343 344 void HandleU4List(const uint32_t* values, size_t count) override { 345 DCHECK_EQ(length_, buffer_.size()); 346 for (size_t i = 0; i < count; ++i) { 347 uint32_t value = *values; 348 buffer_.push_back(static_cast<uint8_t>((value >> 24) & 0xFF)); 349 buffer_.push_back(static_cast<uint8_t>((value >> 16) & 0xFF)); 350 buffer_.push_back(static_cast<uint8_t>((value >> 8) & 0xFF)); 351 buffer_.push_back(static_cast<uint8_t>((value >> 0) & 0xFF)); 352 values++; 353 } 354 } 355 356 void HandleU8List(const uint64_t* values, size_t count) override { 357 DCHECK_EQ(length_, buffer_.size()); 358 for (size_t i = 0; i < count; ++i) { 359 uint64_t value = *values; 360 buffer_.push_back(static_cast<uint8_t>((value >> 56) & 0xFF)); 361 buffer_.push_back(static_cast<uint8_t>((value >> 48) & 0xFF)); 362 buffer_.push_back(static_cast<uint8_t>((value >> 40) & 0xFF)); 363 buffer_.push_back(static_cast<uint8_t>((value >> 32) & 0xFF)); 364 buffer_.push_back(static_cast<uint8_t>((value >> 24) & 0xFF)); 365 buffer_.push_back(static_cast<uint8_t>((value >> 16) & 0xFF)); 366 buffer_.push_back(static_cast<uint8_t>((value >> 8) & 0xFF)); 367 buffer_.push_back(static_cast<uint8_t>((value >> 0) & 0xFF)); 368 values++; 369 } 370 } 371 372 void HandleEndRecord() override { 373 DCHECK_EQ(buffer_.size(), length_); 374 if (kIsDebugBuild && started_) { 375 uint32_t stored_length = 376 static_cast<uint32_t>(buffer_[5]) << 24 | 377 static_cast<uint32_t>(buffer_[6]) << 16 | 378 static_cast<uint32_t>(buffer_[7]) << 8 | 379 static_cast<uint32_t>(buffer_[8]); 380 DCHECK_EQ(stored_length, length_ - sizeof(uint8_t) - 2 * sizeof(uint32_t)); 381 } 382 HandleFlush(buffer_.data(), length_); 383 buffer_.clear(); 384 } 385 386 virtual void HandleFlush(const uint8_t* buffer ATTRIBUTE_UNUSED, size_t length ATTRIBUTE_UNUSED) { 387 } 388 389 std::vector<uint8_t> buffer_; 390 }; 391 392 class FileEndianOutput final : public EndianOutputBuffered { 393 public: 394 FileEndianOutput(File* fp, size_t reserved_size) 395 : EndianOutputBuffered(reserved_size), fp_(fp), errors_(false) { 396 DCHECK(fp != nullptr); 397 } 398 ~FileEndianOutput() { 399 } 400 401 bool Errors() { 402 return errors_; 403 } 404 405 protected: 406 void HandleFlush(const uint8_t* buffer, size_t length) override { 407 if (!errors_) { 408 errors_ = !fp_->WriteFully(buffer, length); 409 } 410 } 411 412 private: 413 File* fp_; 414 bool errors_; 415 }; 416 417 class VectorEndianOuputput final : public EndianOutputBuffered { 418 public: 419 VectorEndianOuputput(std::vector<uint8_t>& data, size_t reserved_size) 420 : EndianOutputBuffered(reserved_size), full_data_(data) {} 421 ~VectorEndianOuputput() {} 422 423 protected: 424 void HandleFlush(const uint8_t* buf, size_t length) override { 425 size_t old_size = full_data_.size(); 426 full_data_.resize(old_size + length); 427 memcpy(full_data_.data() + old_size, buf, length); 428 } 429 430 private: 431 std::vector<uint8_t>& full_data_; 432 }; 433 434 #define __ output_-> 435 436 class Hprof : public SingleRootVisitor { 437 public: 438 Hprof(const char* output_filename, int fd, bool direct_to_ddms) 439 : filename_(output_filename), 440 fd_(fd), 441 direct_to_ddms_(direct_to_ddms) { 442 LOG(INFO) << "hprof: heap dump \"" << filename_ << "\" starting..."; 443 } 444 445 void Dump() 446 REQUIRES(Locks::mutator_lock_) 447 REQUIRES(!Locks::heap_bitmap_lock_, !Locks::alloc_tracker_lock_) { 448 { 449 MutexLock mu(Thread::Current(), *Locks::alloc_tracker_lock_); 450 if (Runtime::Current()->GetHeap()->IsAllocTrackingEnabled()) { 451 PopulateAllocationTrackingTraces(); 452 } 453 } 454 455 // First pass to measure the size of the dump. 456 size_t overall_size; 457 size_t max_length; 458 { 459 EndianOutput count_output; 460 output_ = &count_output; 461 ProcessHeap(false); 462 overall_size = count_output.SumLength(); 463 max_length = count_output.MaxLength(); 464 output_ = nullptr; 465 } 466 467 bool okay; 468 visited_objects_.clear(); 469 if (direct_to_ddms_) { 470 if (kDirectStream) { 471 okay = DumpToDdmsDirect(overall_size, max_length, CHUNK_TYPE("HPDS")); 472 } else { 473 okay = DumpToDdmsBuffered(overall_size, max_length); 474 } 475 } else { 476 okay = DumpToFile(overall_size, max_length); 477 } 478 479 if (okay) { 480 const uint64_t duration = NanoTime() - start_ns_; 481 LOG(INFO) << "hprof: heap dump completed (" << PrettySize(RoundUp(overall_size, KB)) 482 << ") in " << PrettyDuration(duration) 483 << " objects " << total_objects_ 484 << " objects with stack traces " << total_objects_with_stack_trace_; 485 } 486 } 487 488 private: 489 void DumpHeapObject(mirror::Object* obj) 490 REQUIRES_SHARED(Locks::mutator_lock_); 491 492 void DumpHeapClass(mirror::Class* klass) 493 REQUIRES_SHARED(Locks::mutator_lock_); 494 495 void DumpHeapArray(mirror::Array* obj, mirror::Class* klass) 496 REQUIRES_SHARED(Locks::mutator_lock_); 497 498 void DumpFakeObjectArray(mirror::Object* obj, const std::set<mirror::Object*>& elements) 499 REQUIRES_SHARED(Locks::mutator_lock_); 500 501 void DumpHeapInstanceObject(mirror::Object* obj, 502 mirror::Class* klass, 503 const std::set<mirror::Object*>& fake_roots) 504 REQUIRES_SHARED(Locks::mutator_lock_); 505 506 bool AddRuntimeInternalObjectsField(mirror::Class* klass) REQUIRES_SHARED(Locks::mutator_lock_); 507 508 void ProcessHeap(bool header_first) 509 REQUIRES(Locks::mutator_lock_) { 510 // Reset current heap and object count. 511 current_heap_ = HPROF_HEAP_DEFAULT; 512 objects_in_segment_ = 0; 513 514 if (header_first) { 515 ProcessHeader(true); 516 ProcessBody(); 517 } else { 518 ProcessBody(); 519 ProcessHeader(false); 520 } 521 } 522 523 void ProcessBody() REQUIRES(Locks::mutator_lock_) { 524 Runtime* const runtime = Runtime::Current(); 525 // Walk the roots and the heap. 526 output_->StartNewRecord(HPROF_TAG_HEAP_DUMP_SEGMENT, kHprofTime); 527 528 simple_roots_.clear(); 529 runtime->VisitRoots(this); 530 runtime->VisitImageRoots(this); 531 auto dump_object = [this](mirror::Object* obj) REQUIRES_SHARED(Locks::mutator_lock_) { 532 DCHECK(obj != nullptr); 533 DumpHeapObject(obj); 534 }; 535 runtime->GetHeap()->VisitObjectsPaused(dump_object); 536 output_->StartNewRecord(HPROF_TAG_HEAP_DUMP_END, kHprofTime); 537 output_->EndRecord(); 538 } 539 540 void ProcessHeader(bool string_first) REQUIRES(Locks::mutator_lock_) { 541 // Write the header. 542 WriteFixedHeader(); 543 // Write the string and class tables, and any stack traces, to the header. 544 // (jhat requires that these appear before any of the data in the body that refers to them.) 545 // jhat also requires the string table appear before class table and stack traces. 546 // However, WriteStackTraces() can modify the string table, so it's necessary to call 547 // WriteStringTable() last in the first pass, to compute the correct length of the output. 548 if (string_first) { 549 WriteStringTable(); 550 } 551 WriteClassTable(); 552 WriteStackTraces(); 553 if (!string_first) { 554 WriteStringTable(); 555 } 556 output_->EndRecord(); 557 } 558 559 void WriteClassTable() REQUIRES_SHARED(Locks::mutator_lock_) { 560 for (const auto& p : classes_) { 561 mirror::Class* c = p.first; 562 HprofClassSerialNumber sn = p.second; 563 CHECK(c != nullptr); 564 output_->StartNewRecord(HPROF_TAG_LOAD_CLASS, kHprofTime); 565 // LOAD CLASS format: 566 // U4: class serial number (always > 0) 567 // ID: class object ID. We use the address of the class object structure as its ID. 568 // U4: stack trace serial number 569 // ID: class name string ID 570 __ AddU4(sn); 571 __ AddObjectId(c); 572 __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(c)); 573 __ AddStringId(LookupClassNameId(c)); 574 } 575 } 576 577 void WriteStringTable() { 578 for (const auto& p : strings_) { 579 const std::string& string = p.first; 580 const HprofStringId id = p.second; 581 582 output_->StartNewRecord(HPROF_TAG_STRING, kHprofTime); 583 584 // STRING format: 585 // ID: ID for this string 586 // U1*: UTF8 characters for string (NOT null terminated) 587 // (the record format encodes the length) 588 __ AddU4(id); 589 __ AddUtf8String(string.c_str()); 590 } 591 } 592 593 void StartNewHeapDumpSegment() { 594 // This flushes the old segment and starts a new one. 595 output_->StartNewRecord(HPROF_TAG_HEAP_DUMP_SEGMENT, kHprofTime); 596 objects_in_segment_ = 0; 597 // Starting a new HEAP_DUMP resets the heap to default. 598 current_heap_ = HPROF_HEAP_DEFAULT; 599 } 600 601 void CheckHeapSegmentConstraints() { 602 if (objects_in_segment_ >= kMaxObjectsPerSegment || output_->Length() >= kMaxBytesPerSegment) { 603 StartNewHeapDumpSegment(); 604 } 605 } 606 607 void VisitRoot(mirror::Object* obj, const RootInfo& root_info) 608 override REQUIRES_SHARED(Locks::mutator_lock_); 609 void MarkRootObject(const mirror::Object* obj, jobject jni_obj, HprofHeapTag heap_tag, 610 uint32_t thread_serial); 611 612 HprofClassObjectId LookupClassId(mirror::Class* c) REQUIRES_SHARED(Locks::mutator_lock_) { 613 if (c != nullptr) { 614 auto it = classes_.find(c); 615 if (it == classes_.end()) { 616 // first time to see this class 617 HprofClassSerialNumber sn = next_class_serial_number_++; 618 classes_.Put(c, sn); 619 // Make sure that we've assigned a string ID for this class' name 620 LookupClassNameId(c); 621 } 622 } 623 return PointerToLowMemUInt32(c); 624 } 625 626 HprofStackTraceSerialNumber LookupStackTraceSerialNumber(const mirror::Object* obj) 627 REQUIRES_SHARED(Locks::mutator_lock_) { 628 auto r = allocation_records_.find(obj); 629 if (r == allocation_records_.end()) { 630 return kHprofNullStackTrace; 631 } else { 632 const gc::AllocRecordStackTrace* trace = r->second; 633 auto result = traces_.find(trace); 634 CHECK(result != traces_.end()); 635 return result->second; 636 } 637 } 638 639 HprofStringId LookupStringId(mirror::String* string) REQUIRES_SHARED(Locks::mutator_lock_) { 640 return LookupStringId(string->ToModifiedUtf8()); 641 } 642 643 HprofStringId LookupStringId(const char* string) { 644 return LookupStringId(std::string(string)); 645 } 646 647 HprofStringId LookupStringId(const std::string& string) { 648 auto it = strings_.find(string); 649 if (it != strings_.end()) { 650 return it->second; 651 } 652 HprofStringId id = next_string_id_++; 653 strings_.Put(string, id); 654 return id; 655 } 656 657 HprofStringId LookupClassNameId(mirror::Class* c) REQUIRES_SHARED(Locks::mutator_lock_) { 658 return LookupStringId(c->PrettyDescriptor()); 659 } 660 661 void WriteFixedHeader() { 662 // Write the file header. 663 // U1: NUL-terminated magic string. 664 const char magic[] = "JAVA PROFILE 1.0.3"; 665 __ AddU1List(reinterpret_cast<const uint8_t*>(magic), sizeof(magic)); 666 667 // U4: size of identifiers. We're using addresses as IDs and our heap references are stored 668 // as uint32_t. 669 // Note of warning: hprof-conv hard-codes the size of identifiers to 4. 670 static_assert(sizeof(mirror::HeapReference<mirror::Object>) == sizeof(uint32_t), 671 "Unexpected HeapReference size"); 672 __ AddU4(sizeof(uint32_t)); 673 674 // The current time, in milliseconds since 0:00 GMT, 1/1/70. 675 timeval now; 676 const uint64_t nowMs = (gettimeofday(&now, nullptr) < 0) ? 0 : 677 (uint64_t)now.tv_sec * 1000 + now.tv_usec / 1000; 678 // TODO: It seems it would be correct to use U8. 679 // U4: high word of the 64-bit time. 680 __ AddU4(static_cast<uint32_t>(nowMs >> 32)); 681 // U4: low word of the 64-bit time. 682 __ AddU4(static_cast<uint32_t>(nowMs & 0xFFFFFFFF)); 683 } 684 685 void WriteStackTraces() REQUIRES_SHARED(Locks::mutator_lock_) { 686 // Write a dummy stack trace record so the analysis tools don't freak out. 687 output_->StartNewRecord(HPROF_TAG_STACK_TRACE, kHprofTime); 688 __ AddStackTraceSerialNumber(kHprofNullStackTrace); 689 __ AddU4(kHprofNullThread); 690 __ AddU4(0); // no frames 691 692 // TODO: jhat complains "WARNING: Stack trace not found for serial # -1", but no trace should 693 // have -1 as its serial number (as long as HprofStackTraceSerialNumber doesn't overflow). 694 for (const auto& it : traces_) { 695 const gc::AllocRecordStackTrace* trace = it.first; 696 HprofStackTraceSerialNumber trace_sn = it.second; 697 size_t depth = trace->GetDepth(); 698 699 // First write stack frames of the trace 700 for (size_t i = 0; i < depth; ++i) { 701 const gc::AllocRecordStackTraceElement* frame = &trace->GetStackElement(i); 702 ArtMethod* method = frame->GetMethod(); 703 CHECK(method != nullptr); 704 output_->StartNewRecord(HPROF_TAG_STACK_FRAME, kHprofTime); 705 // STACK FRAME format: 706 // ID: stack frame ID. We use the address of the AllocRecordStackTraceElement object as its ID. 707 // ID: method name string ID 708 // ID: method signature string ID 709 // ID: source file name string ID 710 // U4: class serial number 711 // U4: >0, line number; 0, no line information available; -1, unknown location 712 auto frame_result = frames_.find(frame); 713 CHECK(frame_result != frames_.end()); 714 __ AddU4(frame_result->second); 715 __ AddStringId(LookupStringId(method->GetName())); 716 __ AddStringId(LookupStringId(method->GetSignature().ToString())); 717 const char* source_file = method->GetDeclaringClassSourceFile(); 718 if (source_file == nullptr) { 719 source_file = ""; 720 } 721 __ AddStringId(LookupStringId(source_file)); 722 auto class_result = classes_.find(method->GetDeclaringClass().Ptr()); 723 CHECK(class_result != classes_.end()); 724 __ AddU4(class_result->second); 725 __ AddU4(frame->ComputeLineNumber()); 726 } 727 728 // Then write the trace itself 729 output_->StartNewRecord(HPROF_TAG_STACK_TRACE, kHprofTime); 730 // STACK TRACE format: 731 // U4: stack trace serial number. We use the address of the AllocRecordStackTrace object as its serial number. 732 // U4: thread serial number. We use Thread::GetTid(). 733 // U4: number of frames 734 // [ID]*: series of stack frame ID's 735 __ AddStackTraceSerialNumber(trace_sn); 736 __ AddU4(trace->GetTid()); 737 __ AddU4(depth); 738 for (size_t i = 0; i < depth; ++i) { 739 const gc::AllocRecordStackTraceElement* frame = &trace->GetStackElement(i); 740 auto frame_result = frames_.find(frame); 741 CHECK(frame_result != frames_.end()); 742 __ AddU4(frame_result->second); 743 } 744 } 745 } 746 747 bool DumpToDdmsBuffered(size_t overall_size ATTRIBUTE_UNUSED, size_t max_length ATTRIBUTE_UNUSED) 748 REQUIRES(Locks::mutator_lock_) { 749 LOG(FATAL) << "Unimplemented"; 750 UNREACHABLE(); 751 // // Send the data off to DDMS. 752 // iovec iov[2]; 753 // iov[0].iov_base = header_data_ptr_; 754 // iov[0].iov_len = header_data_size_; 755 // iov[1].iov_base = body_data_ptr_; 756 // iov[1].iov_len = body_data_size_; 757 // Dbg::DdmSendChunkV(CHUNK_TYPE("HPDS"), iov, 2); 758 } 759 760 bool DumpToFile(size_t overall_size, size_t max_length) 761 REQUIRES(Locks::mutator_lock_) { 762 // Where exactly are we writing to? 763 int out_fd; 764 if (fd_ >= 0) { 765 out_fd = DupCloexec(fd_); 766 if (out_fd < 0) { 767 ThrowRuntimeException("Couldn't dump heap; dup(%d) failed: %s", fd_, strerror(errno)); 768 return false; 769 } 770 } else { 771 out_fd = open(filename_.c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0644); 772 if (out_fd < 0) { 773 ThrowRuntimeException("Couldn't dump heap; open(\"%s\") failed: %s", filename_.c_str(), 774 strerror(errno)); 775 return false; 776 } 777 } 778 779 std::unique_ptr<File> file(new File(out_fd, filename_, true)); 780 bool okay; 781 { 782 FileEndianOutput file_output(file.get(), max_length); 783 output_ = &file_output; 784 ProcessHeap(true); 785 okay = !file_output.Errors(); 786 787 if (okay) { 788 // Check for expected size. Output is expected to be less-or-equal than first phase, see 789 // b/23521263. 790 DCHECK_LE(file_output.SumLength(), overall_size); 791 } 792 output_ = nullptr; 793 } 794 795 if (okay) { 796 okay = file->FlushCloseOrErase() == 0; 797 } else { 798 file->Erase(); 799 } 800 if (!okay) { 801 std::string msg(android::base::StringPrintf("Couldn't dump heap; writing \"%s\" failed: %s", 802 filename_.c_str(), 803 strerror(errno))); 804 ThrowRuntimeException("%s", msg.c_str()); 805 LOG(ERROR) << msg; 806 } 807 808 return okay; 809 } 810 811 bool DumpToDdmsDirect(size_t overall_size, size_t max_length, uint32_t chunk_type) 812 REQUIRES(Locks::mutator_lock_) { 813 CHECK(direct_to_ddms_); 814 815 std::vector<uint8_t> out_data; 816 817 // TODO It would be really good to have some streaming thing again. b/73084059 818 VectorEndianOuputput output(out_data, max_length); 819 output_ = &output; 820 821 // Write the dump. 822 ProcessHeap(true); 823 824 Runtime::Current()->GetRuntimeCallbacks()->DdmPublishChunk( 825 chunk_type, ArrayRef<const uint8_t>(out_data.data(), out_data.size())); 826 827 // Check for expected size. See DumpToFile for comment. 828 DCHECK_LE(output.SumLength(), overall_size); 829 output_ = nullptr; 830 831 return true; 832 } 833 834 void PopulateAllocationTrackingTraces() 835 REQUIRES(Locks::mutator_lock_, Locks::alloc_tracker_lock_) { 836 gc::AllocRecordObjectMap* records = Runtime::Current()->GetHeap()->GetAllocationRecords(); 837 CHECK(records != nullptr); 838 HprofStackTraceSerialNumber next_trace_sn = kHprofNullStackTrace + 1; 839 HprofStackFrameId next_frame_id = 0; 840 size_t count = 0; 841 842 for (auto it = records->Begin(), end = records->End(); it != end; ++it) { 843 const mirror::Object* obj = it->first.Read(); 844 if (obj == nullptr) { 845 continue; 846 } 847 ++count; 848 const gc::AllocRecordStackTrace* trace = it->second.GetStackTrace(); 849 850 // Copy the pair into a real hash map to speed up look up. 851 auto records_result = allocation_records_.emplace(obj, trace); 852 // The insertion should always succeed, i.e. no duplicate object pointers in "records" 853 CHECK(records_result.second); 854 855 // Generate serial numbers for traces, and IDs for frames. 856 auto traces_result = traces_.find(trace); 857 if (traces_result == traces_.end()) { 858 traces_.emplace(trace, next_trace_sn++); 859 // only check frames if the trace is newly discovered 860 for (size_t i = 0, depth = trace->GetDepth(); i < depth; ++i) { 861 const gc::AllocRecordStackTraceElement* frame = &trace->GetStackElement(i); 862 auto frames_result = frames_.find(frame); 863 if (frames_result == frames_.end()) { 864 frames_.emplace(frame, next_frame_id++); 865 } 866 } 867 } 868 } 869 CHECK_EQ(traces_.size(), next_trace_sn - kHprofNullStackTrace - 1); 870 CHECK_EQ(frames_.size(), next_frame_id); 871 total_objects_with_stack_trace_ = count; 872 } 873 874 // If direct_to_ddms_ is set, "filename_" and "fd" will be ignored. 875 // Otherwise, "filename_" must be valid, though if "fd" >= 0 it will 876 // only be used for debug messages. 877 std::string filename_; 878 int fd_; 879 bool direct_to_ddms_; 880 881 uint64_t start_ns_ = NanoTime(); 882 883 EndianOutput* output_ = nullptr; 884 885 HprofHeapId current_heap_ = HPROF_HEAP_DEFAULT; // Which heap we're currently dumping. 886 size_t objects_in_segment_ = 0; 887 888 size_t total_objects_ = 0u; 889 size_t total_objects_with_stack_trace_ = 0u; 890 891 HprofStringId next_string_id_ = 0x400000; 892 SafeMap<std::string, HprofStringId> strings_; 893 HprofClassSerialNumber next_class_serial_number_ = 1; 894 SafeMap<mirror::Class*, HprofClassSerialNumber> classes_; 895 896 std::unordered_map<const gc::AllocRecordStackTrace*, HprofStackTraceSerialNumber, 897 gc::HashAllocRecordTypesPtr<gc::AllocRecordStackTrace>, 898 gc::EqAllocRecordTypesPtr<gc::AllocRecordStackTrace>> traces_; 899 std::unordered_map<const gc::AllocRecordStackTraceElement*, HprofStackFrameId, 900 gc::HashAllocRecordTypesPtr<gc::AllocRecordStackTraceElement>, 901 gc::EqAllocRecordTypesPtr<gc::AllocRecordStackTraceElement>> frames_; 902 std::unordered_map<const mirror::Object*, const gc::AllocRecordStackTrace*> allocation_records_; 903 904 // Set used to keep track of what simple root records we have already 905 // emitted, to avoid emitting duplicate entries. The simple root records are 906 // those that contain no other information than the root type and the object 907 // id. A pair of root type and object id is packed into a uint64_t, with 908 // the root type in the upper 32 bits and the object id in the lower 32 909 // bits. 910 std::unordered_set<uint64_t> simple_roots_; 911 912 // To make sure we don't dump the same object multiple times. b/34967844 913 std::unordered_set<mirror::Object*> visited_objects_; 914 915 friend class GcRootVisitor; 916 DISALLOW_COPY_AND_ASSIGN(Hprof); 917 }; 918 919 static HprofBasicType SignatureToBasicTypeAndSize(const char* sig, size_t* size_out) { 920 char c = sig[0]; 921 HprofBasicType ret; 922 size_t size; 923 924 switch (c) { 925 case '[': 926 case 'L': 927 ret = hprof_basic_object; 928 size = 4; 929 break; 930 case 'Z': 931 ret = hprof_basic_boolean; 932 size = 1; 933 break; 934 case 'C': 935 ret = hprof_basic_char; 936 size = 2; 937 break; 938 case 'F': 939 ret = hprof_basic_float; 940 size = 4; 941 break; 942 case 'D': 943 ret = hprof_basic_double; 944 size = 8; 945 break; 946 case 'B': 947 ret = hprof_basic_byte; 948 size = 1; 949 break; 950 case 'S': 951 ret = hprof_basic_short; 952 size = 2; 953 break; 954 case 'I': 955 ret = hprof_basic_int; 956 size = 4; 957 break; 958 case 'J': 959 ret = hprof_basic_long; 960 size = 8; 961 break; 962 default: 963 LOG(FATAL) << "UNREACHABLE"; 964 UNREACHABLE(); 965 } 966 967 if (size_out != nullptr) { 968 *size_out = size; 969 } 970 971 return ret; 972 } 973 974 // Always called when marking objects, but only does 975 // something when ctx->gc_scan_state_ is non-zero, which is usually 976 // only true when marking the root set or unreachable 977 // objects. Used to add rootset references to obj. 978 void Hprof::MarkRootObject(const mirror::Object* obj, jobject jni_obj, HprofHeapTag heap_tag, 979 uint32_t thread_serial) { 980 if (heap_tag == 0) { 981 return; 982 } 983 984 CheckHeapSegmentConstraints(); 985 986 switch (heap_tag) { 987 // ID: object ID 988 case HPROF_ROOT_UNKNOWN: 989 case HPROF_ROOT_STICKY_CLASS: 990 case HPROF_ROOT_MONITOR_USED: 991 case HPROF_ROOT_INTERNED_STRING: 992 case HPROF_ROOT_DEBUGGER: 993 case HPROF_ROOT_VM_INTERNAL: { 994 uint64_t key = (static_cast<uint64_t>(heap_tag) << 32) | PointerToLowMemUInt32(obj); 995 if (simple_roots_.insert(key).second) { 996 __ AddU1(heap_tag); 997 __ AddObjectId(obj); 998 } 999 break; 1000 } 1001 1002 // ID: object ID 1003 // ID: JNI global ref ID 1004 case HPROF_ROOT_JNI_GLOBAL: 1005 __ AddU1(heap_tag); 1006 __ AddObjectId(obj); 1007 __ AddJniGlobalRefId(jni_obj); 1008 break; 1009 1010 // ID: object ID 1011 // U4: thread serial number 1012 // U4: frame number in stack trace (-1 for empty) 1013 case HPROF_ROOT_JNI_LOCAL: 1014 case HPROF_ROOT_JNI_MONITOR: 1015 case HPROF_ROOT_JAVA_FRAME: 1016 __ AddU1(heap_tag); 1017 __ AddObjectId(obj); 1018 __ AddU4(thread_serial); 1019 __ AddU4((uint32_t)-1); 1020 break; 1021 1022 // ID: object ID 1023 // U4: thread serial number 1024 case HPROF_ROOT_NATIVE_STACK: 1025 case HPROF_ROOT_THREAD_BLOCK: 1026 __ AddU1(heap_tag); 1027 __ AddObjectId(obj); 1028 __ AddU4(thread_serial); 1029 break; 1030 1031 // ID: thread object ID 1032 // U4: thread serial number 1033 // U4: stack trace serial number 1034 case HPROF_ROOT_THREAD_OBJECT: 1035 __ AddU1(heap_tag); 1036 __ AddObjectId(obj); 1037 __ AddU4(thread_serial); 1038 __ AddU4((uint32_t)-1); // xxx 1039 break; 1040 1041 case HPROF_CLASS_DUMP: 1042 case HPROF_INSTANCE_DUMP: 1043 case HPROF_OBJECT_ARRAY_DUMP: 1044 case HPROF_PRIMITIVE_ARRAY_DUMP: 1045 case HPROF_HEAP_DUMP_INFO: 1046 case HPROF_PRIMITIVE_ARRAY_NODATA_DUMP: 1047 // Ignored. 1048 break; 1049 1050 case HPROF_ROOT_FINALIZING: 1051 case HPROF_ROOT_REFERENCE_CLEANUP: 1052 case HPROF_UNREACHABLE: 1053 LOG(FATAL) << "obsolete tag " << static_cast<int>(heap_tag); 1054 UNREACHABLE(); 1055 } 1056 1057 ++objects_in_segment_; 1058 } 1059 1060 bool Hprof::AddRuntimeInternalObjectsField(mirror::Class* klass) { 1061 if (klass->IsDexCacheClass()) { 1062 return true; 1063 } 1064 // IsClassLoaderClass is true for subclasses of classloader but we only want to add the fake 1065 // field to the java.lang.ClassLoader class. 1066 if (klass->IsClassLoaderClass() && klass->GetSuperClass()->IsObjectClass()) { 1067 return true; 1068 } 1069 return false; 1070 } 1071 1072 void Hprof::DumpHeapObject(mirror::Object* obj) { 1073 // Ignore classes that are retired. 1074 if (obj->IsClass() && obj->AsClass()->IsRetired()) { 1075 return; 1076 } 1077 DCHECK(visited_objects_.insert(obj).second) 1078 << "Already visited " << obj << "(" << obj->PrettyTypeOf() << ")"; 1079 1080 ++total_objects_; 1081 1082 class RootCollector { 1083 public: 1084 RootCollector() {} 1085 1086 void operator()(mirror::Object*, MemberOffset, bool) const {} 1087 1088 // Note that these don't have read barriers. Its OK however since the GC is guaranteed to not be 1089 // running during the hprof dumping process. 1090 void VisitRootIfNonNull(mirror::CompressedReference<mirror::Object>* root) const 1091 REQUIRES_SHARED(Locks::mutator_lock_) { 1092 if (!root->IsNull()) { 1093 VisitRoot(root); 1094 } 1095 } 1096 1097 void VisitRoot(mirror::CompressedReference<mirror::Object>* root) const 1098 REQUIRES_SHARED(Locks::mutator_lock_) { 1099 roots_.insert(root->AsMirrorPtr()); 1100 } 1101 1102 const std::set<mirror::Object*>& GetRoots() const { 1103 return roots_; 1104 } 1105 1106 private: 1107 // These roots are actually live from the object. Avoid marking them as roots in hprof to make 1108 // it easier to debug class unloading. 1109 mutable std::set<mirror::Object*> roots_; 1110 }; 1111 1112 RootCollector visitor; 1113 // Collect all native roots. 1114 if (!obj->IsClass()) { 1115 obj->VisitReferences(visitor, VoidFunctor()); 1116 } 1117 1118 gc::Heap* const heap = Runtime::Current()->GetHeap(); 1119 const gc::space::ContinuousSpace* const space = heap->FindContinuousSpaceFromObject(obj, true); 1120 HprofHeapId heap_type = HPROF_HEAP_APP; 1121 if (space != nullptr) { 1122 if (space->IsZygoteSpace()) { 1123 heap_type = HPROF_HEAP_ZYGOTE; 1124 VisitRoot(obj, RootInfo(kRootVMInternal)); 1125 } else if (space->IsImageSpace() && heap->ObjectIsInBootImageSpace(obj)) { 1126 // Only count objects in the boot image as HPROF_HEAP_IMAGE, this leaves app image objects as 1127 // HPROF_HEAP_APP. b/35762934 1128 heap_type = HPROF_HEAP_IMAGE; 1129 VisitRoot(obj, RootInfo(kRootVMInternal)); 1130 } 1131 } else { 1132 const auto* los = heap->GetLargeObjectsSpace(); 1133 if (los->Contains(obj) && los->IsZygoteLargeObject(Thread::Current(), obj)) { 1134 heap_type = HPROF_HEAP_ZYGOTE; 1135 VisitRoot(obj, RootInfo(kRootVMInternal)); 1136 } 1137 } 1138 CheckHeapSegmentConstraints(); 1139 1140 if (heap_type != current_heap_) { 1141 HprofStringId nameId; 1142 1143 // This object is in a different heap than the current one. 1144 // Emit a HEAP_DUMP_INFO tag to change heaps. 1145 __ AddU1(HPROF_HEAP_DUMP_INFO); 1146 __ AddU4(static_cast<uint32_t>(heap_type)); // uint32_t: heap type 1147 switch (heap_type) { 1148 case HPROF_HEAP_APP: 1149 nameId = LookupStringId("app"); 1150 break; 1151 case HPROF_HEAP_ZYGOTE: 1152 nameId = LookupStringId("zygote"); 1153 break; 1154 case HPROF_HEAP_IMAGE: 1155 nameId = LookupStringId("image"); 1156 break; 1157 default: 1158 // Internal error 1159 LOG(ERROR) << "Unexpected desiredHeap"; 1160 nameId = LookupStringId("<ILLEGAL>"); 1161 break; 1162 } 1163 __ AddStringId(nameId); 1164 current_heap_ = heap_type; 1165 } 1166 1167 mirror::Class* c = obj->GetClass(); 1168 if (c == nullptr) { 1169 // This object will bother HprofReader, because it has a null 1170 // class, so just don't dump it. It could be 1171 // gDvm.unlinkedJavaLangClass or it could be an object just 1172 // allocated which hasn't been initialized yet. 1173 } else { 1174 if (obj->IsClass()) { 1175 DumpHeapClass(obj->AsClass().Ptr()); 1176 } else if (c->IsArrayClass()) { 1177 DumpHeapArray(obj->AsArray().Ptr(), c); 1178 } else { 1179 DumpHeapInstanceObject(obj, c, visitor.GetRoots()); 1180 } 1181 } 1182 1183 ++objects_in_segment_; 1184 } 1185 1186 void Hprof::DumpHeapClass(mirror::Class* klass) { 1187 if (!klass->IsResolved()) { 1188 // Class is allocated but not yet resolved: we cannot access its fields or super class. 1189 return; 1190 } 1191 1192 // Note: We will emit instance fields of Class as synthetic static fields with a prefix of 1193 // "$class$" so the class fields are visible in hprof dumps. For tools to account for that 1194 // correctly, we'll emit an instance size of zero for java.lang.Class, and also emit the 1195 // instance fields of java.lang.Object. 1196 // 1197 // For other overhead (currently only the embedded vtable), we will generate a synthetic 1198 // byte array (or field[s] in case the overhead size is of reference size or less). 1199 1200 const size_t num_static_fields = klass->NumStaticFields(); 1201 1202 // Total class size: 1203 // * class instance fields (including Object instance fields) 1204 // * vtable 1205 // * class static fields 1206 const size_t total_class_size = klass->GetClassSize(); 1207 1208 // Base class size (common parts of all Class instances): 1209 // * class instance fields (including Object instance fields) 1210 constexpr size_t base_class_size = sizeof(mirror::Class); 1211 CHECK_LE(base_class_size, total_class_size); 1212 1213 // Difference of Total and Base: 1214 // * vtable 1215 // * class static fields 1216 const size_t base_overhead_size = total_class_size - base_class_size; 1217 1218 // Tools (ahat/Studio) will count the static fields and account for them in the class size. We 1219 // must thus subtract them from base_overhead_size or they will be double-counted. 1220 size_t class_static_fields_size = 0; 1221 for (ArtField& class_static_field : klass->GetSFields()) { 1222 size_t size = 0; 1223 SignatureToBasicTypeAndSize(class_static_field.GetTypeDescriptor(), &size); 1224 class_static_fields_size += size; 1225 } 1226 1227 CHECK_GE(base_overhead_size, class_static_fields_size); 1228 // Now we have: 1229 // * vtable 1230 const size_t base_no_statics_overhead_size = base_overhead_size - class_static_fields_size; 1231 1232 // We may decide to display native overhead (the actual IMT, ArtFields and ArtMethods) in the 1233 // future. 1234 const size_t java_heap_overhead_size = base_no_statics_overhead_size; 1235 1236 // For overhead greater 4, we'll allocate a synthetic array. 1237 if (java_heap_overhead_size > 4) { 1238 // Create a byte array to reflect the allocation of the 1239 // StaticField array at the end of this class. 1240 __ AddU1(HPROF_PRIMITIVE_ARRAY_DUMP); 1241 __ AddClassStaticsId(klass); 1242 __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(klass)); 1243 __ AddU4(java_heap_overhead_size - 4); 1244 __ AddU1(hprof_basic_byte); 1245 for (size_t i = 0; i < java_heap_overhead_size - 4; ++i) { 1246 __ AddU1(0); 1247 } 1248 } 1249 const size_t java_heap_overhead_field_count = java_heap_overhead_size > 0 1250 ? (java_heap_overhead_size == 3 ? 2u : 1u) 1251 : 0; 1252 1253 __ AddU1(HPROF_CLASS_DUMP); 1254 __ AddClassId(LookupClassId(klass)); 1255 __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(klass)); 1256 __ AddClassId(LookupClassId(klass->GetSuperClass().Ptr())); 1257 __ AddObjectId(klass->GetClassLoader().Ptr()); 1258 __ AddObjectId(nullptr); // no signer 1259 __ AddObjectId(nullptr); // no prot domain 1260 __ AddObjectId(nullptr); // reserved 1261 __ AddObjectId(nullptr); // reserved 1262 // Instance size. 1263 if (klass->IsClassClass()) { 1264 // As mentioned above, we will emit instance fields as synthetic static fields. So the 1265 // base object is "empty." 1266 __ AddU4(0); 1267 } else if (klass->IsStringClass()) { 1268 // Strings are variable length with character data at the end like arrays. 1269 // This outputs the size of an empty string. 1270 __ AddU4(sizeof(mirror::String)); 1271 } else if (klass->IsArrayClass() || klass->IsPrimitive()) { 1272 __ AddU4(0); 1273 } else { 1274 __ AddU4(klass->GetObjectSize()); // instance size 1275 } 1276 1277 __ AddU2(0); // empty const pool 1278 1279 // Static fields 1280 // 1281 // Note: we report Class' and Object's instance fields here, too. This is for visibility reasons. 1282 // (b/38167721) 1283 mirror::Class* class_class = klass->GetClass(); 1284 1285 DCHECK(class_class->GetSuperClass()->IsObjectClass()); 1286 const size_t static_fields_reported = class_class->NumInstanceFields() 1287 + class_class->GetSuperClass()->NumInstanceFields() 1288 + java_heap_overhead_field_count 1289 + num_static_fields; 1290 __ AddU2(dchecked_integral_cast<uint16_t>(static_fields_reported)); 1291 1292 if (java_heap_overhead_size != 0) { 1293 __ AddStringId(LookupStringId(kClassOverheadName)); 1294 size_t overhead_fields = 0; 1295 if (java_heap_overhead_size > 4) { 1296 __ AddU1(hprof_basic_object); 1297 __ AddClassStaticsId(klass); 1298 ++overhead_fields; 1299 } else { 1300 switch (java_heap_overhead_size) { 1301 case 4: { 1302 __ AddU1(hprof_basic_int); 1303 __ AddU4(0); 1304 ++overhead_fields; 1305 break; 1306 } 1307 1308 case 2: { 1309 __ AddU1(hprof_basic_short); 1310 __ AddU2(0); 1311 ++overhead_fields; 1312 break; 1313 } 1314 1315 case 3: { 1316 __ AddU1(hprof_basic_short); 1317 __ AddU2(0); 1318 __ AddStringId(LookupStringId(std::string(kClassOverheadName) + "2")); 1319 ++overhead_fields; 1320 } 1321 FALLTHROUGH_INTENDED; 1322 1323 case 1: { 1324 __ AddU1(hprof_basic_byte); 1325 __ AddU1(0); 1326 ++overhead_fields; 1327 break; 1328 } 1329 } 1330 } 1331 DCHECK_EQ(java_heap_overhead_field_count, overhead_fields); 1332 } 1333 1334 // Helper lambda to emit the given static field. The second argument name_fn will be called to 1335 // generate the name to emit. This can be used to emit something else than the field's actual 1336 // name. 1337 auto static_field_writer = [&](ArtField& field, auto name_fn) 1338 REQUIRES_SHARED(Locks::mutator_lock_) { 1339 __ AddStringId(LookupStringId(name_fn(field))); 1340 1341 size_t size; 1342 HprofBasicType t = SignatureToBasicTypeAndSize(field.GetTypeDescriptor(), &size); 1343 __ AddU1(t); 1344 switch (t) { 1345 case hprof_basic_byte: 1346 __ AddU1(field.GetByte(klass)); 1347 return; 1348 case hprof_basic_boolean: 1349 __ AddU1(field.GetBoolean(klass)); 1350 return; 1351 case hprof_basic_char: 1352 __ AddU2(field.GetChar(klass)); 1353 return; 1354 case hprof_basic_short: 1355 __ AddU2(field.GetShort(klass)); 1356 return; 1357 case hprof_basic_float: 1358 case hprof_basic_int: 1359 case hprof_basic_object: 1360 __ AddU4(field.Get32(klass)); 1361 return; 1362 case hprof_basic_double: 1363 case hprof_basic_long: 1364 __ AddU8(field.Get64(klass)); 1365 return; 1366 } 1367 LOG(FATAL) << "Unexpected size " << size; 1368 UNREACHABLE(); 1369 }; 1370 1371 { 1372 auto class_instance_field_name_fn = [](ArtField& field) REQUIRES_SHARED(Locks::mutator_lock_) { 1373 return std::string("$class$") + field.GetName(); 1374 }; 1375 for (ArtField& class_instance_field : class_class->GetIFields()) { 1376 static_field_writer(class_instance_field, class_instance_field_name_fn); 1377 } 1378 for (ArtField& object_instance_field : class_class->GetSuperClass()->GetIFields()) { 1379 static_field_writer(object_instance_field, class_instance_field_name_fn); 1380 } 1381 } 1382 1383 { 1384 auto class_static_field_name_fn = [](ArtField& field) REQUIRES_SHARED(Locks::mutator_lock_) { 1385 return field.GetName(); 1386 }; 1387 for (ArtField& class_static_field : klass->GetSFields()) { 1388 static_field_writer(class_static_field, class_static_field_name_fn); 1389 } 1390 } 1391 1392 // Instance fields for this class (no superclass fields) 1393 int iFieldCount = klass->NumInstanceFields(); 1394 // add_internal_runtime_objects is only for classes that may retain objects live through means 1395 // other than fields. It is never the case for strings. 1396 const bool add_internal_runtime_objects = AddRuntimeInternalObjectsField(klass); 1397 if (klass->IsStringClass() || add_internal_runtime_objects) { 1398 __ AddU2((uint16_t)iFieldCount + 1); 1399 } else { 1400 __ AddU2((uint16_t)iFieldCount); 1401 } 1402 for (int i = 0; i < iFieldCount; ++i) { 1403 ArtField* f = klass->GetInstanceField(i); 1404 __ AddStringId(LookupStringId(f->GetName())); 1405 HprofBasicType t = SignatureToBasicTypeAndSize(f->GetTypeDescriptor(), nullptr); 1406 __ AddU1(t); 1407 } 1408 // Add native value character array for strings / byte array for compressed strings. 1409 if (klass->IsStringClass()) { 1410 __ AddStringId(LookupStringId("value")); 1411 __ AddU1(hprof_basic_object); 1412 } else if (add_internal_runtime_objects) { 1413 __ AddStringId(LookupStringId("runtimeInternalObjects")); 1414 __ AddU1(hprof_basic_object); 1415 } 1416 } 1417 1418 void Hprof::DumpFakeObjectArray(mirror::Object* obj, const std::set<mirror::Object*>& elements) { 1419 __ AddU1(HPROF_OBJECT_ARRAY_DUMP); 1420 __ AddObjectId(obj); 1421 __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(obj)); 1422 __ AddU4(elements.size()); 1423 __ AddClassId(LookupClassId(GetClassRoot<mirror::ObjectArray<mirror::Object>>().Ptr())); 1424 for (mirror::Object* e : elements) { 1425 __ AddObjectId(e); 1426 } 1427 } 1428 1429 void Hprof::DumpHeapArray(mirror::Array* obj, mirror::Class* klass) { 1430 uint32_t length = obj->GetLength(); 1431 1432 if (obj->IsObjectArray()) { 1433 // obj is an object array. 1434 __ AddU1(HPROF_OBJECT_ARRAY_DUMP); 1435 1436 __ AddObjectId(obj); 1437 __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(obj)); 1438 __ AddU4(length); 1439 __ AddClassId(LookupClassId(klass)); 1440 1441 // Dump the elements, which are always objects or null. 1442 __ AddIdList(obj->AsObjectArray<mirror::Object>().Ptr()); 1443 } else { 1444 size_t size; 1445 HprofBasicType t = SignatureToBasicTypeAndSize( 1446 Primitive::Descriptor(klass->GetComponentType()->GetPrimitiveType()), &size); 1447 1448 // obj is a primitive array. 1449 __ AddU1(HPROF_PRIMITIVE_ARRAY_DUMP); 1450 1451 __ AddObjectId(obj); 1452 __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(obj)); 1453 __ AddU4(length); 1454 __ AddU1(t); 1455 1456 // Dump the raw, packed element values. 1457 if (size == 1) { 1458 __ AddU1List(reinterpret_cast<const uint8_t*>(obj->GetRawData(sizeof(uint8_t), 0)), length); 1459 } else if (size == 2) { 1460 __ AddU2List(reinterpret_cast<const uint16_t*>(obj->GetRawData(sizeof(uint16_t), 0)), length); 1461 } else if (size == 4) { 1462 __ AddU4List(reinterpret_cast<const uint32_t*>(obj->GetRawData(sizeof(uint32_t), 0)), length); 1463 } else if (size == 8) { 1464 __ AddU8List(reinterpret_cast<const uint64_t*>(obj->GetRawData(sizeof(uint64_t), 0)), length); 1465 } 1466 } 1467 } 1468 1469 void Hprof::DumpHeapInstanceObject(mirror::Object* obj, 1470 mirror::Class* klass, 1471 const std::set<mirror::Object*>& fake_roots) { 1472 // obj is an instance object. 1473 __ AddU1(HPROF_INSTANCE_DUMP); 1474 __ AddObjectId(obj); 1475 __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(obj)); 1476 __ AddClassId(LookupClassId(klass)); 1477 1478 // Reserve some space for the length of the instance data, which we won't 1479 // know until we're done writing it. 1480 size_t size_patch_offset = output_->Length(); 1481 __ AddU4(0x77777777); 1482 1483 // What we will use for the string value if the object is a string. 1484 mirror::Object* string_value = nullptr; 1485 mirror::Object* fake_object_array = nullptr; 1486 1487 // Write the instance data; fields for this class, followed by super class fields, and so on. 1488 do { 1489 const size_t instance_fields = klass->NumInstanceFields(); 1490 for (size_t i = 0; i < instance_fields; ++i) { 1491 ArtField* f = klass->GetInstanceField(i); 1492 size_t size; 1493 HprofBasicType t = SignatureToBasicTypeAndSize(f->GetTypeDescriptor(), &size); 1494 switch (t) { 1495 case hprof_basic_byte: 1496 __ AddU1(f->GetByte(obj)); 1497 break; 1498 case hprof_basic_boolean: 1499 __ AddU1(f->GetBoolean(obj)); 1500 break; 1501 case hprof_basic_char: 1502 __ AddU2(f->GetChar(obj)); 1503 break; 1504 case hprof_basic_short: 1505 __ AddU2(f->GetShort(obj)); 1506 break; 1507 case hprof_basic_int: 1508 if (mirror::kUseStringCompression && 1509 klass->IsStringClass() && 1510 f->GetOffset().SizeValue() == mirror::String::CountOffset().SizeValue()) { 1511 // Store the string length instead of the raw count field with compression flag. 1512 __ AddU4(obj->AsString()->GetLength()); 1513 break; 1514 } 1515 FALLTHROUGH_INTENDED; 1516 case hprof_basic_float: 1517 case hprof_basic_object: 1518 __ AddU4(f->Get32(obj)); 1519 break; 1520 case hprof_basic_double: 1521 case hprof_basic_long: 1522 __ AddU8(f->Get64(obj)); 1523 break; 1524 } 1525 } 1526 // Add value field for String if necessary. 1527 if (klass->IsStringClass()) { 1528 ObjPtr<mirror::String> s = obj->AsString(); 1529 if (s->GetLength() == 0) { 1530 // If string is empty, use an object-aligned address within the string for the value. 1531 string_value = reinterpret_cast<mirror::Object*>( 1532 reinterpret_cast<uintptr_t>(s.Ptr()) + kObjectAlignment); 1533 } else { 1534 if (s->IsCompressed()) { 1535 string_value = reinterpret_cast<mirror::Object*>(s->GetValueCompressed()); 1536 } else { 1537 string_value = reinterpret_cast<mirror::Object*>(s->GetValue()); 1538 } 1539 } 1540 __ AddObjectId(string_value); 1541 } else if (AddRuntimeInternalObjectsField(klass)) { 1542 // We need an id that is guaranteed to not be used, use 1/2 of the object alignment. 1543 fake_object_array = reinterpret_cast<mirror::Object*>( 1544 reinterpret_cast<uintptr_t>(obj) + kObjectAlignment / 2); 1545 __ AddObjectId(fake_object_array); 1546 } 1547 klass = klass->GetSuperClass().Ptr(); 1548 } while (klass != nullptr); 1549 1550 // Patch the instance field length. 1551 __ UpdateU4(size_patch_offset, output_->Length() - (size_patch_offset + 4)); 1552 1553 // Output native value character array for strings. 1554 CHECK_EQ(obj->IsString(), string_value != nullptr); 1555 if (string_value != nullptr) { 1556 ObjPtr<mirror::String> s = obj->AsString(); 1557 __ AddU1(HPROF_PRIMITIVE_ARRAY_DUMP); 1558 __ AddObjectId(string_value); 1559 __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(obj)); 1560 __ AddU4(s->GetLength()); 1561 if (s->IsCompressed()) { 1562 __ AddU1(hprof_basic_byte); 1563 __ AddU1List(s->GetValueCompressed(), s->GetLength()); 1564 } else { 1565 __ AddU1(hprof_basic_char); 1566 __ AddU2List(s->GetValue(), s->GetLength()); 1567 } 1568 } else if (fake_object_array != nullptr) { 1569 DumpFakeObjectArray(fake_object_array, fake_roots); 1570 } 1571 } 1572 1573 void Hprof::VisitRoot(mirror::Object* obj, const RootInfo& info) { 1574 static const HprofHeapTag xlate[] = { 1575 HPROF_ROOT_UNKNOWN, 1576 HPROF_ROOT_JNI_GLOBAL, 1577 HPROF_ROOT_JNI_LOCAL, 1578 HPROF_ROOT_JAVA_FRAME, 1579 HPROF_ROOT_NATIVE_STACK, 1580 HPROF_ROOT_STICKY_CLASS, 1581 HPROF_ROOT_THREAD_BLOCK, 1582 HPROF_ROOT_MONITOR_USED, 1583 HPROF_ROOT_THREAD_OBJECT, 1584 HPROF_ROOT_INTERNED_STRING, 1585 HPROF_ROOT_FINALIZING, 1586 HPROF_ROOT_DEBUGGER, 1587 HPROF_ROOT_REFERENCE_CLEANUP, 1588 HPROF_ROOT_VM_INTERNAL, 1589 HPROF_ROOT_JNI_MONITOR, 1590 }; 1591 CHECK_LT(info.GetType(), sizeof(xlate) / sizeof(HprofHeapTag)); 1592 if (obj == nullptr) { 1593 return; 1594 } 1595 MarkRootObject(obj, nullptr, xlate[info.GetType()], info.GetThreadId()); 1596 } 1597 1598 // If "direct_to_ddms" is true, the other arguments are ignored, and data is 1599 // sent directly to DDMS. 1600 // If "fd" is >= 0, the output will be written to that file descriptor. 1601 // Otherwise, "filename" is used to create an output file. 1602 void DumpHeap(const char* filename, int fd, bool direct_to_ddms) { 1603 CHECK(filename != nullptr); 1604 Thread* self = Thread::Current(); 1605 // Need to take a heap dump while GC isn't running. See the comment in Heap::VisitObjects(). 1606 // Also we need the critical section to avoid visiting the same object twice. See b/34967844 1607 gc::ScopedGCCriticalSection gcs(self, 1608 gc::kGcCauseHprof, 1609 gc::kCollectorTypeHprof); 1610 ScopedSuspendAll ssa(__FUNCTION__, true /* long suspend */); 1611 Hprof hprof(filename, fd, direct_to_ddms); 1612 hprof.Dump(); 1613 } 1614 1615 } // namespace hprof 1616 } // namespace art 1617
