trace_event_memory_overhead.cc 5.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173
  1. // Copyright 2015 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "base/trace_event/trace_event_memory_overhead.h"
  5. #include <algorithm>
  6. #include "base/bits.h"
  7. #include "base/memory/ref_counted_memory.h"
  8. #include "base/notreached.h"
  9. #include "base/strings/stringprintf.h"
  10. #include "base/trace_event/memory_allocator_dump.h"
  11. #include "base/trace_event/memory_usage_estimator.h"
  12. #include "base/trace_event/process_memory_dump.h"
  13. #include "base/values.h"
  14. namespace base {
  15. namespace trace_event {
  16. namespace {
  17. const char* ObjectTypeToString(TraceEventMemoryOverhead::ObjectType type) {
  18. switch (type) {
  19. case TraceEventMemoryOverhead::kOther:
  20. return "(Other)";
  21. case TraceEventMemoryOverhead::kTraceBuffer:
  22. return "TraceBuffer";
  23. case TraceEventMemoryOverhead::kTraceBufferChunk:
  24. return "TraceBufferChunk";
  25. case TraceEventMemoryOverhead::kTraceEvent:
  26. return "TraceEvent";
  27. case TraceEventMemoryOverhead::kUnusedTraceEvent:
  28. return "TraceEvent(Unused)";
  29. case TraceEventMemoryOverhead::kTracedValue:
  30. return "TracedValue";
  31. case TraceEventMemoryOverhead::kConvertableToTraceFormat:
  32. return "ConvertableToTraceFormat";
  33. case TraceEventMemoryOverhead::kHeapProfilerAllocationRegister:
  34. return "AllocationRegister";
  35. case TraceEventMemoryOverhead::kHeapProfilerTypeNameDeduplicator:
  36. return "TypeNameDeduplicator";
  37. case TraceEventMemoryOverhead::kHeapProfilerStackFrameDeduplicator:
  38. return "StackFrameDeduplicator";
  39. case TraceEventMemoryOverhead::kStdString:
  40. return "std::string";
  41. case TraceEventMemoryOverhead::kBaseValue:
  42. return "base::Value";
  43. case TraceEventMemoryOverhead::kTraceEventMemoryOverhead:
  44. return "TraceEventMemoryOverhead";
  45. case TraceEventMemoryOverhead::kFrameMetrics:
  46. return "FrameMetrics";
  47. case TraceEventMemoryOverhead::kLast:
  48. NOTREACHED();
  49. }
  50. NOTREACHED();
  51. return "BUG";
  52. }
  53. } // namespace
  54. TraceEventMemoryOverhead::TraceEventMemoryOverhead() : allocated_objects_() {}
  55. TraceEventMemoryOverhead::~TraceEventMemoryOverhead() = default;
  56. void TraceEventMemoryOverhead::AddInternal(ObjectType object_type,
  57. size_t count,
  58. size_t allocated_size_in_bytes,
  59. size_t resident_size_in_bytes) {
  60. ObjectCountAndSize& count_and_size =
  61. allocated_objects_[static_cast<uint32_t>(object_type)];
  62. count_and_size.count += count;
  63. count_and_size.allocated_size_in_bytes += allocated_size_in_bytes;
  64. count_and_size.resident_size_in_bytes += resident_size_in_bytes;
  65. }
  66. void TraceEventMemoryOverhead::Add(ObjectType object_type,
  67. size_t allocated_size_in_bytes) {
  68. Add(object_type, allocated_size_in_bytes, allocated_size_in_bytes);
  69. }
  70. void TraceEventMemoryOverhead::Add(ObjectType object_type,
  71. size_t allocated_size_in_bytes,
  72. size_t resident_size_in_bytes) {
  73. AddInternal(object_type, 1, allocated_size_in_bytes, resident_size_in_bytes);
  74. }
  75. void TraceEventMemoryOverhead::AddString(const std::string& str) {
  76. Add(kStdString, EstimateMemoryUsage(str));
  77. }
  78. void TraceEventMemoryOverhead::AddRefCountedString(
  79. const RefCountedString& str) {
  80. Add(kOther, sizeof(RefCountedString));
  81. AddString(str.data());
  82. }
  83. void TraceEventMemoryOverhead::AddValue(const Value& value) {
  84. switch (value.type()) {
  85. case Value::Type::NONE:
  86. case Value::Type::BOOLEAN:
  87. case Value::Type::INTEGER:
  88. case Value::Type::DOUBLE:
  89. Add(kBaseValue, sizeof(Value));
  90. break;
  91. case Value::Type::STRING:
  92. Add(kBaseValue, sizeof(Value));
  93. AddString(value.GetString());
  94. break;
  95. case Value::Type::BINARY:
  96. Add(kBaseValue, sizeof(Value) + value.GetBlob().size());
  97. break;
  98. case Value::Type::DICTIONARY:
  99. Add(kBaseValue, sizeof(Value));
  100. for (const auto pair : value.DictItems()) {
  101. AddString(pair.first);
  102. AddValue(pair.second);
  103. }
  104. break;
  105. case Value::Type::LIST:
  106. Add(kBaseValue, sizeof(Value));
  107. for (const auto& v : value.GetListDeprecated())
  108. AddValue(v);
  109. break;
  110. default:
  111. NOTREACHED();
  112. }
  113. }
  114. void TraceEventMemoryOverhead::AddSelf() {
  115. Add(kTraceEventMemoryOverhead, sizeof(*this));
  116. }
  117. size_t TraceEventMemoryOverhead::GetCount(ObjectType object_type) const {
  118. CHECK(object_type < kLast);
  119. return allocated_objects_[static_cast<uint32_t>(object_type)].count;
  120. }
  121. void TraceEventMemoryOverhead::Update(const TraceEventMemoryOverhead& other) {
  122. for (uint32_t i = 0; i < kLast; i++) {
  123. const ObjectCountAndSize& other_entry = other.allocated_objects_[i];
  124. AddInternal(static_cast<ObjectType>(i), other_entry.count,
  125. other_entry.allocated_size_in_bytes,
  126. other_entry.resident_size_in_bytes);
  127. }
  128. }
  129. void TraceEventMemoryOverhead::DumpInto(const char* base_name,
  130. ProcessMemoryDump* pmd) const {
  131. for (uint32_t i = 0; i < kLast; i++) {
  132. const ObjectCountAndSize& count_and_size = allocated_objects_[i];
  133. if (count_and_size.allocated_size_in_bytes == 0)
  134. continue;
  135. std::string dump_name = StringPrintf(
  136. "%s/%s", base_name, ObjectTypeToString(static_cast<ObjectType>(i)));
  137. MemoryAllocatorDump* mad = pmd->CreateAllocatorDump(dump_name);
  138. mad->AddScalar(MemoryAllocatorDump::kNameSize,
  139. MemoryAllocatorDump::kUnitsBytes,
  140. count_and_size.allocated_size_in_bytes);
  141. mad->AddScalar("resident_size", MemoryAllocatorDump::kUnitsBytes,
  142. count_and_size.resident_size_in_bytes);
  143. mad->AddScalar(MemoryAllocatorDump::kNameObjectCount,
  144. MemoryAllocatorDump::kUnitsObjects, count_and_size.count);
  145. }
  146. }
  147. } // namespace trace_event
  148. } // namespace base