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