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
12 namespace v8 {
13 namespace internal {
14
15 static base::LazyMutex object_stats_mutex = LAZY_MUTEX_INITIALIZER;
16
17
ClearObjectStats(bool clear_last_time_stats)18 void 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
TraceObjectStat(const char * name,int count,int size,double time)28 void 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
TraceObjectStats()37 void 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
CheckpointObjectStats()76 void 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
isolate()135 Isolate* ObjectStats::isolate() { return heap()->isolate(); }
136
137
CountFixedArray(FixedArrayBase * fixed_array,FixedArraySubInstanceType fast_type,FixedArraySubInstanceType dictionary_type)138 void 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
VisitBase(VisitorId id,Map * map,HeapObject * obj)156 void 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
171 template <ObjectStatsVisitor::VisitorId id>
Visit(Map * map,HeapObject * obj)172 void ObjectStatsVisitor::Visit(Map* map, HeapObject* obj) {
173 VisitBase(id, map, obj);
174 }
175
176
177 template <>
Visit(Map * map,HeapObject * obj)178 void 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
203 template <>
Visit(Map * map,HeapObject * obj)204 void 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
216 template <>
Visit(Map * map,HeapObject * obj)217 void 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
229 template <>
Visit(Map * map,HeapObject * obj)230 void 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
Initialize(VisitorDispatchTable<Callback> * original)242 void 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
253