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