Gitiles
Code Review Sign In
gerrit-public.fairphone.software / fp2-dev / platform / external / v8 / 4a90d5fbbb6802c59093b866f3478a814bf02b95 / . / src / heap / object-stats.cc
blob: c1566abfc5cf6accc1a20fc666310b57d0951c3b [file] [log] [blame]
Ben Murdoch4a90d5f2016-03-22 12:00:34 +0000[diff] [blame^]1// Copyright 2015 the V8 project 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
5#include "src/heap/object-stats.h"
6
7#include "src/counters.h"
8#include "src/heap/heap-inl.h"
9#include "src/isolate.h"
10#include "src/utils.h"
11
12namespace v8 {
13namespace internal {
14
15static base::LazyMutex object_stats_mutex = LAZY_MUTEX_INITIALIZER;
16
17
18void ObjectStats::ClearObjectStats(bool clear_last_time_stats) {
19 memset(object_counts_, 0, sizeof(object_counts_));
20 memset(object_sizes_, 0, sizeof(object_sizes_));
21 if (clear_last_time_stats) {
22 memset(object_counts_last_time_, 0, sizeof(object_counts_last_time_));
23 memset(object_sizes_last_time_, 0, sizeof(object_sizes_last_time_));
24 }
25}
26
27
28void ObjectStats::TraceObjectStat(const char* name, int count, int size,
29 double time) {
30 int ms_count = heap()->ms_count();
31 PrintIsolate(isolate(),
32 "heap:%p, time:%f, gc:%d, type:%s, count:%d, size:%d\n",
33 static_cast<void*>(heap()), time, ms_count, name, count, size);
34}
35
36
37void ObjectStats::TraceObjectStats() {
38 base::LockGuard<base::Mutex> lock_guard(object_stats_mutex.Pointer());
39 int index;
40 int count;
41 int size;
42 int total_size = 0;
43 double time = isolate()->time_millis_since_init();
44#define TRACE_OBJECT_COUNT(name) \
45 count = static_cast<int>(object_counts_[name]); \
46 size = static_cast<int>(object_sizes_[name]) / KB; \
47 total_size += size; \
48 TraceObjectStat(#name, count, size, time);
49 INSTANCE_TYPE_LIST(TRACE_OBJECT_COUNT)
50#undef TRACE_OBJECT_COUNT
51#define TRACE_OBJECT_COUNT(name) \
52 index = FIRST_CODE_KIND_SUB_TYPE + Code::name; \
53 count = static_cast<int>(object_counts_[index]); \
54 size = static_cast<int>(object_sizes_[index]) / KB; \
55 TraceObjectStat("*CODE_" #name, count, size, time);
56 CODE_KIND_LIST(TRACE_OBJECT_COUNT)
57#undef TRACE_OBJECT_COUNT
58#define TRACE_OBJECT_COUNT(name) \
59 index = FIRST_FIXED_ARRAY_SUB_TYPE + name; \
60 count = static_cast<int>(object_counts_[index]); \
61 size = static_cast<int>(object_sizes_[index]) / KB; \
62 TraceObjectStat("*FIXED_ARRAY_" #name, count, size, time);
63 FIXED_ARRAY_SUB_INSTANCE_TYPE_LIST(TRACE_OBJECT_COUNT)
64#undef TRACE_OBJECT_COUNT
65#define TRACE_OBJECT_COUNT(name) \
66 index = \
67 FIRST_CODE_AGE_SUB_TYPE + Code::k##name##CodeAge - Code::kFirstCodeAge; \
68 count = static_cast<int>(object_counts_[index]); \
69 size = static_cast<int>(object_sizes_[index]) / KB; \
70 TraceObjectStat("*CODE_AGE_" #name, count, size, time);
71 CODE_AGE_LIST_COMPLETE(TRACE_OBJECT_COUNT)
72#undef TRACE_OBJECT_COUNT
73}
74
75
76void ObjectStats::CheckpointObjectStats() {
77 base::LockGuard<base::Mutex> lock_guard(object_stats_mutex.Pointer());
78 Counters* counters = isolate()->counters();
79#define ADJUST_LAST_TIME_OBJECT_COUNT(name) \
80 counters->count_of_##name()->Increment( \
81 static_cast<int>(object_counts_[name])); \
82 counters->count_of_##name()->Decrement( \
83 static_cast<int>(object_counts_last_time_[name])); \
84 counters->size_of_##name()->Increment( \
85 static_cast<int>(object_sizes_[name])); \
86 counters->size_of_##name()->Decrement( \
87 static_cast<int>(object_sizes_last_time_[name]));
88 INSTANCE_TYPE_LIST(ADJUST_LAST_TIME_OBJECT_COUNT)
89#undef ADJUST_LAST_TIME_OBJECT_COUNT
90 int index;
91#define ADJUST_LAST_TIME_OBJECT_COUNT(name) \
92 index = FIRST_CODE_KIND_SUB_TYPE + Code::name; \
93 counters->count_of_CODE_TYPE_##name()->Increment( \
94 static_cast<int>(object_counts_[index])); \
95 counters->count_of_CODE_TYPE_##name()->Decrement( \
96 static_cast<int>(object_counts_last_time_[index])); \
97 counters->size_of_CODE_TYPE_##name()->Increment( \
98 static_cast<int>(object_sizes_[index])); \
99 counters->size_of_CODE_TYPE_##name()->Decrement( \
100 static_cast<int>(object_sizes_last_time_[index]));
101 CODE_KIND_LIST(ADJUST_LAST_TIME_OBJECT_COUNT)
102#undef ADJUST_LAST_TIME_OBJECT_COUNT
103#define ADJUST_LAST_TIME_OBJECT_COUNT(name) \
104 index = FIRST_FIXED_ARRAY_SUB_TYPE + name; \
105 counters->count_of_FIXED_ARRAY_##name()->Increment( \
106 static_cast<int>(object_counts_[index])); \
107 counters->count_of_FIXED_ARRAY_##name()->Decrement( \
108 static_cast<int>(object_counts_last_time_[index])); \
109 counters->size_of_FIXED_ARRAY_##name()->Increment( \
110 static_cast<int>(object_sizes_[index])); \
111 counters->size_of_FIXED_ARRAY_##name()->Decrement( \
112 static_cast<int>(object_sizes_last_time_[index]));
113 FIXED_ARRAY_SUB_INSTANCE_TYPE_LIST(ADJUST_LAST_TIME_OBJECT_COUNT)
114#undef ADJUST_LAST_TIME_OBJECT_COUNT
115#define ADJUST_LAST_TIME_OBJECT_COUNT(name) \
116 index = \
117 FIRST_CODE_AGE_SUB_TYPE + Code::k##name##CodeAge - Code::kFirstCodeAge; \
118 counters->count_of_CODE_AGE_##name()->Increment( \
119 static_cast<int>(object_counts_[index])); \
120 counters->count_of_CODE_AGE_##name()->Decrement( \
121 static_cast<int>(object_counts_last_time_[index])); \
122 counters->size_of_CODE_AGE_##name()->Increment( \
123 static_cast<int>(object_sizes_[index])); \
124 counters->size_of_CODE_AGE_##name()->Decrement( \
125 static_cast<int>(object_sizes_last_time_[index]));
126 CODE_AGE_LIST_COMPLETE(ADJUST_LAST_TIME_OBJECT_COUNT)
127#undef ADJUST_LAST_TIME_OBJECT_COUNT
128
129 MemCopy(object_counts_last_time_, object_counts_, sizeof(object_counts_));
130 MemCopy(object_sizes_last_time_, object_sizes_, sizeof(object_sizes_));
131 ClearObjectStats();
132}
133
134
135Isolate* ObjectStats::isolate() { return heap()->isolate(); }
136
137
138void ObjectStatsVisitor::CountFixedArray(
139 FixedArrayBase* fixed_array, FixedArraySubInstanceType fast_type,
140 FixedArraySubInstanceType dictionary_type) {
141 Heap* heap = fixed_array->map()->GetHeap();
142 if (fixed_array->map() != heap->fixed_cow_array_map() &&
143 fixed_array->map() != heap->fixed_double_array_map() &&
144 fixed_array != heap->empty_fixed_array()) {
145 if (fixed_array->IsDictionary()) {
146 heap->object_stats_->RecordFixedArraySubTypeStats(dictionary_type,
147 fixed_array->Size());
148 } else {
149 heap->object_stats_->RecordFixedArraySubTypeStats(fast_type,
150 fixed_array->Size());
151 }
152 }
153}
154
155
156void ObjectStatsVisitor::VisitBase(VisitorId id, Map* map, HeapObject* obj) {
157 Heap* heap = map->GetHeap();
158 int object_size = obj->Size();
159 heap->object_stats_->RecordObjectStats(map->instance_type(), object_size);
160 table_.GetVisitorById(id)(map, obj);
161 if (obj->IsJSObject()) {
162 JSObject* object = JSObject::cast(obj);
163 CountFixedArray(object->elements(), DICTIONARY_ELEMENTS_SUB_TYPE,
164 FAST_ELEMENTS_SUB_TYPE);
165 CountFixedArray(object->properties(), DICTIONARY_PROPERTIES_SUB_TYPE,
166 FAST_PROPERTIES_SUB_TYPE);
167 }
168}
169
170
171template <ObjectStatsVisitor::VisitorId id>
172void ObjectStatsVisitor::Visit(Map* map, HeapObject* obj) {
173 VisitBase(id, map, obj);
174}
175
176
177template <>
178void ObjectStatsVisitor::Visit<ObjectStatsVisitor::kVisitMap>(Map* map,
179 HeapObject* obj) {
180 Heap* heap = map->GetHeap();
181 Map* map_obj = Map::cast(obj);
182 DCHECK(map->instance_type() == MAP_TYPE);
183 DescriptorArray* array = map_obj->instance_descriptors();
184 if (map_obj->owns_descriptors() && array != heap->empty_descriptor_array()) {
185 int fixed_array_size = array->Size();
186 heap->object_stats_->RecordFixedArraySubTypeStats(DESCRIPTOR_ARRAY_SUB_TYPE,
187 fixed_array_size);
188 }
189 if (map_obj->has_code_cache()) {
190 CodeCache* cache = CodeCache::cast(map_obj->code_cache());
191 heap->object_stats_->RecordFixedArraySubTypeStats(
192 MAP_CODE_CACHE_SUB_TYPE, cache->default_cache()->Size());
193 if (!cache->normal_type_cache()->IsUndefined()) {
194 heap->object_stats_->RecordFixedArraySubTypeStats(
195 MAP_CODE_CACHE_SUB_TYPE,
196 FixedArray::cast(cache->normal_type_cache())->Size());
197 }
198 }
199 VisitBase(kVisitMap, map, obj);
200}
201
202
203template <>
204void ObjectStatsVisitor::Visit<ObjectStatsVisitor::kVisitCode>(
205 Map* map, HeapObject* obj) {
206 Heap* heap = map->GetHeap();
207 int object_size = obj->Size();
208 DCHECK(map->instance_type() == CODE_TYPE);
209 Code* code_obj = Code::cast(obj);
210 heap->object_stats_->RecordCodeSubTypeStats(code_obj->kind(),
211 code_obj->GetAge(), object_size);
212 VisitBase(kVisitCode, map, obj);
213}
214
215
216template <>
217void ObjectStatsVisitor::Visit<ObjectStatsVisitor::kVisitSharedFunctionInfo>(
218 Map* map, HeapObject* obj) {
219 Heap* heap = map->GetHeap();
220 SharedFunctionInfo* sfi = SharedFunctionInfo::cast(obj);
221 if (sfi->scope_info() != heap->empty_fixed_array()) {
222 heap->object_stats_->RecordFixedArraySubTypeStats(
223 SCOPE_INFO_SUB_TYPE, FixedArray::cast(sfi->scope_info())->Size());
224 }
225 VisitBase(kVisitSharedFunctionInfo, map, obj);
226}
227
228
229template <>
230void ObjectStatsVisitor::Visit<ObjectStatsVisitor::kVisitFixedArray>(
231 Map* map, HeapObject* obj) {
232 Heap* heap = map->GetHeap();
233 FixedArray* fixed_array = FixedArray::cast(obj);
234 if (fixed_array == heap->string_table()) {
235 heap->object_stats_->RecordFixedArraySubTypeStats(STRING_TABLE_SUB_TYPE,
236 fixed_array->Size());
237 }
238 VisitBase(kVisitFixedArray, map, obj);
239}
240
241
242void ObjectStatsVisitor::Initialize(VisitorDispatchTable<Callback>* original) {
243 // Copy the original visitor table to make call-through possible. After we
244 // preserved a copy locally, we patch the original table to call us.
245 table_.CopyFrom(original);
246#define COUNT_FUNCTION(id) original->Register(kVisit##id, Visit<kVisit##id>);
247 VISITOR_ID_LIST(COUNT_FUNCTION)
248#undef COUNT_FUNCTION
249}
250
251} // namespace internal
252} // namespace v8