OLD | NEW |
1 // Copyright 2011 the V8 project authors. All rights reserved. | 1 // Copyright 2011 the V8 project authors. All rights reserved. |
2 // Redistribution and use in source and binary forms, with or without | 2 // Redistribution and use in source and binary forms, with or without |
3 // modification, are permitted provided that the following conditions are | 3 // modification, are permitted provided that the following conditions are |
4 // met: | 4 // met: |
5 // | 5 // |
6 // * Redistributions of source code must retain the above copyright | 6 // * Redistributions of source code must retain the above copyright |
7 // notice, this list of conditions and the following disclaimer. | 7 // notice, this list of conditions and the following disclaimer. |
8 // * Redistributions in binary form must reproduce the above | 8 // * Redistributions in binary form must reproduce the above |
9 // copyright notice, this list of conditions and the following | 9 // copyright notice, this list of conditions and the following |
10 // disclaimer in the documentation and/or other materials provided | 10 // disclaimer in the documentation and/or other materials provided |
(...skipping 111 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
122 if (strcmp(contents, *node_name) == 0) return true; | 122 if (strcmp(contents, *node_name) == 0) return true; |
123 } | 123 } |
124 } | 124 } |
125 return false; | 125 return false; |
126 } | 126 } |
127 | 127 |
128 | 128 |
129 TEST(HeapSnapshot) { | 129 TEST(HeapSnapshot) { |
130 LocalContext env2; | 130 LocalContext env2; |
131 v8::HandleScope scope(env2->GetIsolate()); | 131 v8::HandleScope scope(env2->GetIsolate()); |
132 v8::HeapProfiler* heap_profiler = env2->GetIsolate()->GetHeapProfiler(); | |
133 | 132 |
134 CompileRun( | 133 CompileRun( |
135 "function A2() {}\n" | 134 "function A2() {}\n" |
136 "function B2(x) { return function() { return typeof x; }; }\n" | 135 "function B2(x) { return function() { return typeof x; }; }\n" |
137 "function C2(x) { this.x1 = x; this.x2 = x; this[1] = x; }\n" | 136 "function C2(x) { this.x1 = x; this.x2 = x; this[1] = x; }\n" |
138 "var a2 = new A2();\n" | 137 "var a2 = new A2();\n" |
139 "var b2_1 = new B2(a2), b2_2 = new B2(a2);\n" | 138 "var b2_1 = new B2(a2), b2_2 = new B2(a2);\n" |
140 "var c2 = new C2(a2);"); | 139 "var c2 = new C2(a2);"); |
141 const v8::HeapSnapshot* snapshot_env2 = | 140 const v8::HeapSnapshot* snapshot_env2 = |
142 heap_profiler->TakeHeapSnapshot(v8_str("env2")); | 141 v8::HeapProfiler::TakeSnapshot(v8_str("env2")); |
143 const v8::HeapGraphNode* global_env2 = GetGlobalObject(snapshot_env2); | 142 const v8::HeapGraphNode* global_env2 = GetGlobalObject(snapshot_env2); |
144 | 143 |
145 // Verify, that JS global object of env2 has '..2' properties. | 144 // Verify, that JS global object of env2 has '..2' properties. |
146 const v8::HeapGraphNode* a2_node = | 145 const v8::HeapGraphNode* a2_node = |
147 GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "a2"); | 146 GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "a2"); |
148 CHECK_NE(NULL, a2_node); | 147 CHECK_NE(NULL, a2_node); |
149 CHECK_NE( | 148 CHECK_NE( |
150 NULL, GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "b2_1")); | 149 NULL, GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "b2_1")); |
151 CHECK_NE( | 150 CHECK_NE( |
152 NULL, GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "b2_2")); | 151 NULL, GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "b2_2")); |
153 CHECK_NE(NULL, GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "c2")); | 152 CHECK_NE(NULL, GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "c2")); |
154 | 153 |
155 NamedEntriesDetector det; | 154 NamedEntriesDetector det; |
156 det.CheckAllReachables(const_cast<i::HeapEntry*>( | 155 det.CheckAllReachables(const_cast<i::HeapEntry*>( |
157 reinterpret_cast<const i::HeapEntry*>(global_env2))); | 156 reinterpret_cast<const i::HeapEntry*>(global_env2))); |
158 CHECK(det.has_A2); | 157 CHECK(det.has_A2); |
159 CHECK(det.has_B2); | 158 CHECK(det.has_B2); |
160 CHECK(det.has_C2); | 159 CHECK(det.has_C2); |
161 } | 160 } |
162 | 161 |
163 | 162 |
164 TEST(HeapSnapshotObjectSizes) { | 163 TEST(HeapSnapshotObjectSizes) { |
165 LocalContext env; | 164 LocalContext env; |
166 v8::HandleScope scope(env->GetIsolate()); | 165 v8::HandleScope scope(env->GetIsolate()); |
167 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
168 | 166 |
169 // -a-> X1 --a | 167 // -a-> X1 --a |
170 // x -b-> X2 <-| | 168 // x -b-> X2 <-| |
171 CompileRun( | 169 CompileRun( |
172 "function X(a, b) { this.a = a; this.b = b; }\n" | 170 "function X(a, b) { this.a = a; this.b = b; }\n" |
173 "x = new X(new X(), new X());\n" | 171 "x = new X(new X(), new X());\n" |
174 "dummy = new X();\n" | 172 "dummy = new X();\n" |
175 "(function() { x.a.a = x.b; })();"); | 173 "(function() { x.a.a = x.b; })();"); |
176 const v8::HeapSnapshot* snapshot = | 174 const v8::HeapSnapshot* snapshot = |
177 heap_profiler->TakeHeapSnapshot(v8_str("sizes")); | 175 v8::HeapProfiler::TakeSnapshot(v8_str("sizes")); |
178 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); | 176 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); |
179 const v8::HeapGraphNode* x = | 177 const v8::HeapGraphNode* x = |
180 GetProperty(global, v8::HeapGraphEdge::kProperty, "x"); | 178 GetProperty(global, v8::HeapGraphEdge::kProperty, "x"); |
181 CHECK_NE(NULL, x); | 179 CHECK_NE(NULL, x); |
182 const v8::HeapGraphNode* x1 = | 180 const v8::HeapGraphNode* x1 = |
183 GetProperty(x, v8::HeapGraphEdge::kProperty, "a"); | 181 GetProperty(x, v8::HeapGraphEdge::kProperty, "a"); |
184 CHECK_NE(NULL, x1); | 182 CHECK_NE(NULL, x1); |
185 const v8::HeapGraphNode* x2 = | 183 const v8::HeapGraphNode* x2 = |
186 GetProperty(x, v8::HeapGraphEdge::kProperty, "b"); | 184 GetProperty(x, v8::HeapGraphEdge::kProperty, "b"); |
187 CHECK_NE(NULL, x2); | 185 CHECK_NE(NULL, x2); |
188 | 186 |
189 // Test sizes. | 187 // Test sizes. |
190 CHECK_NE(0, x->GetSelfSize()); | 188 CHECK_NE(0, x->GetSelfSize()); |
191 CHECK_NE(0, x1->GetSelfSize()); | 189 CHECK_NE(0, x1->GetSelfSize()); |
192 CHECK_NE(0, x2->GetSelfSize()); | 190 CHECK_NE(0, x2->GetSelfSize()); |
193 } | 191 } |
194 | 192 |
195 | 193 |
196 TEST(BoundFunctionInSnapshot) { | 194 TEST(BoundFunctionInSnapshot) { |
197 LocalContext env; | 195 LocalContext env; |
198 v8::HandleScope scope(env->GetIsolate()); | 196 v8::HandleScope scope(env->GetIsolate()); |
199 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
200 CompileRun( | 197 CompileRun( |
201 "function myFunction(a, b) { this.a = a; this.b = b; }\n" | 198 "function myFunction(a, b) { this.a = a; this.b = b; }\n" |
202 "function AAAAA() {}\n" | 199 "function AAAAA() {}\n" |
203 "boundFunction = myFunction.bind(new AAAAA(), 20, new Number(12)); \n"); | 200 "boundFunction = myFunction.bind(new AAAAA(), 20, new Number(12)); \n"); |
204 const v8::HeapSnapshot* snapshot = | 201 const v8::HeapSnapshot* snapshot = |
205 heap_profiler->TakeHeapSnapshot(v8_str("sizes")); | 202 v8::HeapProfiler::TakeSnapshot(v8_str("sizes")); |
206 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); | 203 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); |
207 const v8::HeapGraphNode* f = | 204 const v8::HeapGraphNode* f = |
208 GetProperty(global, v8::HeapGraphEdge::kProperty, "boundFunction"); | 205 GetProperty(global, v8::HeapGraphEdge::kProperty, "boundFunction"); |
209 CHECK(f); | 206 CHECK(f); |
210 CHECK_EQ(v8::String::New("native_bind"), f->GetName()); | 207 CHECK_EQ(v8::String::New("native_bind"), f->GetName()); |
211 const v8::HeapGraphNode* bindings = | 208 const v8::HeapGraphNode* bindings = |
212 GetProperty(f, v8::HeapGraphEdge::kInternal, "bindings"); | 209 GetProperty(f, v8::HeapGraphEdge::kInternal, "bindings"); |
213 CHECK_NE(NULL, bindings); | 210 CHECK_NE(NULL, bindings); |
214 CHECK_EQ(v8::HeapGraphNode::kArray, bindings->GetType()); | 211 CHECK_EQ(v8::HeapGraphNode::kArray, bindings->GetType()); |
215 CHECK_EQ(4, bindings->GetChildrenCount()); | 212 CHECK_EQ(4, bindings->GetChildrenCount()); |
(...skipping 11 matching lines...) Expand all Loading... |
227 const v8::HeapGraphNode* bound_argument = GetProperty( | 224 const v8::HeapGraphNode* bound_argument = GetProperty( |
228 f, v8::HeapGraphEdge::kShortcut, "bound_argument_1"); | 225 f, v8::HeapGraphEdge::kShortcut, "bound_argument_1"); |
229 CHECK(bound_argument); | 226 CHECK(bound_argument); |
230 CHECK_EQ(v8::HeapGraphNode::kObject, bound_argument->GetType()); | 227 CHECK_EQ(v8::HeapGraphNode::kObject, bound_argument->GetType()); |
231 } | 228 } |
232 | 229 |
233 | 230 |
234 TEST(HeapSnapshotEntryChildren) { | 231 TEST(HeapSnapshotEntryChildren) { |
235 LocalContext env; | 232 LocalContext env; |
236 v8::HandleScope scope(env->GetIsolate()); | 233 v8::HandleScope scope(env->GetIsolate()); |
237 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
238 | 234 |
239 CompileRun( | 235 CompileRun( |
240 "function A() { }\n" | 236 "function A() { }\n" |
241 "a = new A;"); | 237 "a = new A;"); |
242 const v8::HeapSnapshot* snapshot = | 238 const v8::HeapSnapshot* snapshot = |
243 heap_profiler->TakeHeapSnapshot(v8_str("children")); | 239 v8::HeapProfiler::TakeSnapshot(v8_str("children")); |
244 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); | 240 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); |
245 for (int i = 0, count = global->GetChildrenCount(); i < count; ++i) { | 241 for (int i = 0, count = global->GetChildrenCount(); i < count; ++i) { |
246 const v8::HeapGraphEdge* prop = global->GetChild(i); | 242 const v8::HeapGraphEdge* prop = global->GetChild(i); |
247 CHECK_EQ(global, prop->GetFromNode()); | 243 CHECK_EQ(global, prop->GetFromNode()); |
248 } | 244 } |
249 const v8::HeapGraphNode* a = | 245 const v8::HeapGraphNode* a = |
250 GetProperty(global, v8::HeapGraphEdge::kProperty, "a"); | 246 GetProperty(global, v8::HeapGraphEdge::kProperty, "a"); |
251 CHECK_NE(NULL, a); | 247 CHECK_NE(NULL, a); |
252 for (int i = 0, count = a->GetChildrenCount(); i < count; ++i) { | 248 for (int i = 0, count = a->GetChildrenCount(); i < count; ++i) { |
253 const v8::HeapGraphEdge* prop = a->GetChild(i); | 249 const v8::HeapGraphEdge* prop = a->GetChild(i); |
254 CHECK_EQ(a, prop->GetFromNode()); | 250 CHECK_EQ(a, prop->GetFromNode()); |
255 } | 251 } |
256 } | 252 } |
257 | 253 |
258 | 254 |
259 TEST(HeapSnapshotCodeObjects) { | 255 TEST(HeapSnapshotCodeObjects) { |
260 LocalContext env; | 256 LocalContext env; |
261 v8::HandleScope scope(env->GetIsolate()); | 257 v8::HandleScope scope(env->GetIsolate()); |
262 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
263 | 258 |
264 CompileRun( | 259 CompileRun( |
265 "function lazy(x) { return x - 1; }\n" | 260 "function lazy(x) { return x - 1; }\n" |
266 "function compiled(x) { return x + 1; }\n" | 261 "function compiled(x) { return x + 1; }\n" |
267 "var anonymous = (function() { return function() { return 0; } })();\n" | 262 "var anonymous = (function() { return function() { return 0; } })();\n" |
268 "compiled(1)"); | 263 "compiled(1)"); |
269 const v8::HeapSnapshot* snapshot = | 264 const v8::HeapSnapshot* snapshot = |
270 heap_profiler->TakeHeapSnapshot(v8_str("code")); | 265 v8::HeapProfiler::TakeSnapshot(v8_str("code")); |
271 | 266 |
272 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); | 267 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); |
273 const v8::HeapGraphNode* compiled = | 268 const v8::HeapGraphNode* compiled = |
274 GetProperty(global, v8::HeapGraphEdge::kProperty, "compiled"); | 269 GetProperty(global, v8::HeapGraphEdge::kProperty, "compiled"); |
275 CHECK_NE(NULL, compiled); | 270 CHECK_NE(NULL, compiled); |
276 CHECK_EQ(v8::HeapGraphNode::kClosure, compiled->GetType()); | 271 CHECK_EQ(v8::HeapGraphNode::kClosure, compiled->GetType()); |
277 const v8::HeapGraphNode* lazy = | 272 const v8::HeapGraphNode* lazy = |
278 GetProperty(global, v8::HeapGraphEdge::kProperty, "lazy"); | 273 GetProperty(global, v8::HeapGraphEdge::kProperty, "lazy"); |
279 CHECK_NE(NULL, lazy); | 274 CHECK_NE(NULL, lazy); |
280 CHECK_EQ(v8::HeapGraphNode::kClosure, lazy->GetType()); | 275 CHECK_EQ(v8::HeapGraphNode::kClosure, lazy->GetType()); |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
318 } | 313 } |
319 } | 314 } |
320 CHECK(compiled_references_x); | 315 CHECK(compiled_references_x); |
321 CHECK(!lazy_references_x); | 316 CHECK(!lazy_references_x); |
322 } | 317 } |
323 | 318 |
324 | 319 |
325 TEST(HeapSnapshotHeapNumbers) { | 320 TEST(HeapSnapshotHeapNumbers) { |
326 LocalContext env; | 321 LocalContext env; |
327 v8::HandleScope scope(env->GetIsolate()); | 322 v8::HandleScope scope(env->GetIsolate()); |
328 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
329 CompileRun( | 323 CompileRun( |
330 "a = 1; // a is Smi\n" | 324 "a = 1; // a is Smi\n" |
331 "b = 2.5; // b is HeapNumber"); | 325 "b = 2.5; // b is HeapNumber"); |
332 const v8::HeapSnapshot* snapshot = | 326 const v8::HeapSnapshot* snapshot = |
333 heap_profiler->TakeHeapSnapshot(v8_str("numbers")); | 327 v8::HeapProfiler::TakeSnapshot(v8_str("numbers")); |
334 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); | 328 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); |
335 CHECK_EQ(NULL, GetProperty(global, v8::HeapGraphEdge::kProperty, "a")); | 329 CHECK_EQ(NULL, GetProperty(global, v8::HeapGraphEdge::kProperty, "a")); |
336 const v8::HeapGraphNode* b = | 330 const v8::HeapGraphNode* b = |
337 GetProperty(global, v8::HeapGraphEdge::kProperty, "b"); | 331 GetProperty(global, v8::HeapGraphEdge::kProperty, "b"); |
338 CHECK_NE(NULL, b); | 332 CHECK_NE(NULL, b); |
339 CHECK_EQ(v8::HeapGraphNode::kHeapNumber, b->GetType()); | 333 CHECK_EQ(v8::HeapGraphNode::kHeapNumber, b->GetType()); |
340 } | 334 } |
341 | 335 |
342 TEST(HeapSnapshotSlicedString) { | 336 TEST(HeapSnapshotSlicedString) { |
343 LocalContext env; | 337 LocalContext env; |
344 v8::HandleScope scope(env->GetIsolate()); | 338 v8::HandleScope scope(env->GetIsolate()); |
345 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
346 CompileRun( | 339 CompileRun( |
347 "parent_string = \"123456789.123456789.123456789.123456789.123456789." | 340 "parent_string = \"123456789.123456789.123456789.123456789.123456789." |
348 "123456789.123456789.123456789.123456789.123456789." | 341 "123456789.123456789.123456789.123456789.123456789." |
349 "123456789.123456789.123456789.123456789.123456789." | 342 "123456789.123456789.123456789.123456789.123456789." |
350 "123456789.123456789.123456789.123456789.123456789.\";" | 343 "123456789.123456789.123456789.123456789.123456789.\";" |
351 "child_string = parent_string.slice(100);"); | 344 "child_string = parent_string.slice(100);"); |
352 const v8::HeapSnapshot* snapshot = | 345 const v8::HeapSnapshot* snapshot = |
353 heap_profiler->TakeHeapSnapshot(v8_str("strings")); | 346 v8::HeapProfiler::TakeSnapshot(v8_str("strings")); |
354 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); | 347 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); |
355 const v8::HeapGraphNode* parent_string = | 348 const v8::HeapGraphNode* parent_string = |
356 GetProperty(global, v8::HeapGraphEdge::kProperty, "parent_string"); | 349 GetProperty(global, v8::HeapGraphEdge::kProperty, "parent_string"); |
357 CHECK_NE(NULL, parent_string); | 350 CHECK_NE(NULL, parent_string); |
358 const v8::HeapGraphNode* child_string = | 351 const v8::HeapGraphNode* child_string = |
359 GetProperty(global, v8::HeapGraphEdge::kProperty, "child_string"); | 352 GetProperty(global, v8::HeapGraphEdge::kProperty, "child_string"); |
360 CHECK_NE(NULL, child_string); | 353 CHECK_NE(NULL, child_string); |
361 const v8::HeapGraphNode* parent = | 354 const v8::HeapGraphNode* parent = |
362 GetProperty(child_string, v8::HeapGraphEdge::kInternal, "parent"); | 355 GetProperty(child_string, v8::HeapGraphEdge::kInternal, "parent"); |
363 CHECK_EQ(parent_string, parent); | 356 CHECK_EQ(parent_string, parent); |
364 } | 357 } |
365 | 358 |
366 TEST(HeapSnapshotInternalReferences) { | 359 TEST(HeapSnapshotInternalReferences) { |
367 v8::Isolate* isolate = v8::Isolate::GetCurrent(); | 360 v8::HandleScope scope(v8::Isolate::GetCurrent()); |
368 v8::HandleScope scope(isolate); | |
369 v8::Local<v8::ObjectTemplate> global_template = v8::ObjectTemplate::New(); | 361 v8::Local<v8::ObjectTemplate> global_template = v8::ObjectTemplate::New(); |
370 global_template->SetInternalFieldCount(2); | 362 global_template->SetInternalFieldCount(2); |
371 LocalContext env(NULL, global_template); | 363 LocalContext env(NULL, global_template); |
372 v8::Handle<v8::Object> global_proxy = env->Global(); | 364 v8::Handle<v8::Object> global_proxy = env->Global(); |
373 v8::Handle<v8::Object> global = global_proxy->GetPrototype().As<v8::Object>(); | 365 v8::Handle<v8::Object> global = global_proxy->GetPrototype().As<v8::Object>(); |
374 CHECK_EQ(2, global->InternalFieldCount()); | 366 CHECK_EQ(2, global->InternalFieldCount()); |
375 v8::Local<v8::Object> obj = v8::Object::New(); | 367 v8::Local<v8::Object> obj = v8::Object::New(); |
376 global->SetInternalField(0, v8_num(17)); | 368 global->SetInternalField(0, v8_num(17)); |
377 global->SetInternalField(1, obj); | 369 global->SetInternalField(1, obj); |
378 v8::HeapProfiler* heap_profiler = isolate->GetHeapProfiler(); | |
379 const v8::HeapSnapshot* snapshot = | 370 const v8::HeapSnapshot* snapshot = |
380 heap_profiler->TakeHeapSnapshot(v8_str("internals")); | 371 v8::HeapProfiler::TakeSnapshot(v8_str("internals")); |
381 const v8::HeapGraphNode* global_node = GetGlobalObject(snapshot); | 372 const v8::HeapGraphNode* global_node = GetGlobalObject(snapshot); |
382 // The first reference will not present, because it's a Smi. | 373 // The first reference will not present, because it's a Smi. |
383 CHECK_EQ(NULL, GetProperty(global_node, v8::HeapGraphEdge::kInternal, "0")); | 374 CHECK_EQ(NULL, GetProperty(global_node, v8::HeapGraphEdge::kInternal, "0")); |
384 // The second reference is to an object. | 375 // The second reference is to an object. |
385 CHECK_NE(NULL, GetProperty(global_node, v8::HeapGraphEdge::kInternal, "1")); | 376 CHECK_NE(NULL, GetProperty(global_node, v8::HeapGraphEdge::kInternal, "1")); |
386 } | 377 } |
387 | 378 |
388 | 379 |
389 // Trying to introduce a check helper for uint32_t causes many | 380 // Trying to introduce a check helper for uint32_t causes many |
390 // overloading ambiguities, so it seems easier just to cast | 381 // overloading ambiguities, so it seems easier just to cast |
391 // them to a signed type. | 382 // them to a signed type. |
392 #define CHECK_EQ_SNAPSHOT_OBJECT_ID(a, b) \ | 383 #define CHECK_EQ_SNAPSHOT_OBJECT_ID(a, b) \ |
393 CHECK_EQ(static_cast<int32_t>(a), static_cast<int32_t>(b)) | 384 CHECK_EQ(static_cast<int32_t>(a), static_cast<int32_t>(b)) |
394 #define CHECK_NE_SNAPSHOT_OBJECT_ID(a, b) \ | 385 #define CHECK_NE_SNAPSHOT_OBJECT_ID(a, b) \ |
395 CHECK((a) != (b)) // NOLINT | 386 CHECK((a) != (b)) // NOLINT |
396 | 387 |
397 TEST(HeapSnapshotAddressReuse) { | 388 TEST(HeapSnapshotAddressReuse) { |
398 LocalContext env; | 389 LocalContext env; |
399 v8::HandleScope scope(env->GetIsolate()); | 390 v8::HandleScope scope(env->GetIsolate()); |
400 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
401 | 391 |
402 CompileRun( | 392 CompileRun( |
403 "function A() {}\n" | 393 "function A() {}\n" |
404 "var a = [];\n" | 394 "var a = [];\n" |
405 "for (var i = 0; i < 10000; ++i)\n" | 395 "for (var i = 0; i < 10000; ++i)\n" |
406 " a[i] = new A();\n"); | 396 " a[i] = new A();\n"); |
407 const v8::HeapSnapshot* snapshot1 = | 397 const v8::HeapSnapshot* snapshot1 = |
408 heap_profiler->TakeHeapSnapshot(v8_str("snapshot1")); | 398 v8::HeapProfiler::TakeSnapshot(v8_str("snapshot1")); |
409 v8::SnapshotObjectId maxId1 = snapshot1->GetMaxSnapshotJSObjectId(); | 399 v8::SnapshotObjectId maxId1 = snapshot1->GetMaxSnapshotJSObjectId(); |
410 | 400 |
411 CompileRun( | 401 CompileRun( |
412 "for (var i = 0; i < 10000; ++i)\n" | 402 "for (var i = 0; i < 10000; ++i)\n" |
413 " a[i] = new A();\n"); | 403 " a[i] = new A();\n"); |
414 HEAP->CollectAllGarbage(i::Heap::kNoGCFlags); | 404 HEAP->CollectAllGarbage(i::Heap::kNoGCFlags); |
415 | 405 |
416 const v8::HeapSnapshot* snapshot2 = | 406 const v8::HeapSnapshot* snapshot2 = |
417 heap_profiler->TakeHeapSnapshot(v8_str("snapshot2")); | 407 v8::HeapProfiler::TakeSnapshot(v8_str("snapshot2")); |
418 const v8::HeapGraphNode* global2 = GetGlobalObject(snapshot2); | 408 const v8::HeapGraphNode* global2 = GetGlobalObject(snapshot2); |
419 | 409 |
420 const v8::HeapGraphNode* array_node = | 410 const v8::HeapGraphNode* array_node = |
421 GetProperty(global2, v8::HeapGraphEdge::kProperty, "a"); | 411 GetProperty(global2, v8::HeapGraphEdge::kProperty, "a"); |
422 CHECK_NE(NULL, array_node); | 412 CHECK_NE(NULL, array_node); |
423 int wrong_count = 0; | 413 int wrong_count = 0; |
424 for (int i = 0, count = array_node->GetChildrenCount(); i < count; ++i) { | 414 for (int i = 0, count = array_node->GetChildrenCount(); i < count; ++i) { |
425 const v8::HeapGraphEdge* prop = array_node->GetChild(i); | 415 const v8::HeapGraphEdge* prop = array_node->GetChild(i); |
426 if (prop->GetType() != v8::HeapGraphEdge::kElement) | 416 if (prop->GetType() != v8::HeapGraphEdge::kElement) |
427 continue; | 417 continue; |
428 v8::SnapshotObjectId id = prop->GetToNode()->GetId(); | 418 v8::SnapshotObjectId id = prop->GetToNode()->GetId(); |
429 if (id < maxId1) | 419 if (id < maxId1) |
430 ++wrong_count; | 420 ++wrong_count; |
431 } | 421 } |
432 CHECK_EQ(0, wrong_count); | 422 CHECK_EQ(0, wrong_count); |
433 } | 423 } |
434 | 424 |
435 | 425 |
436 TEST(HeapEntryIdsAndArrayShift) { | 426 TEST(HeapEntryIdsAndArrayShift) { |
437 LocalContext env; | 427 LocalContext env; |
438 v8::HandleScope scope(env->GetIsolate()); | 428 v8::HandleScope scope(env->GetIsolate()); |
439 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
440 | 429 |
441 CompileRun( | 430 CompileRun( |
442 "function AnObject() {\n" | 431 "function AnObject() {\n" |
443 " this.first = 'first';\n" | 432 " this.first = 'first';\n" |
444 " this.second = 'second';\n" | 433 " this.second = 'second';\n" |
445 "}\n" | 434 "}\n" |
446 "var a = new Array();\n" | 435 "var a = new Array();\n" |
447 "for (var i = 0; i < 10; ++i)\n" | 436 "for (var i = 0; i < 10; ++i)\n" |
448 " a.push(new AnObject());\n"); | 437 " a.push(new AnObject());\n"); |
449 const v8::HeapSnapshot* snapshot1 = | 438 const v8::HeapSnapshot* snapshot1 = |
450 heap_profiler->TakeHeapSnapshot(v8_str("s1")); | 439 v8::HeapProfiler::TakeSnapshot(v8_str("s1")); |
451 | 440 |
452 CompileRun( | 441 CompileRun( |
453 "for (var i = 0; i < 1; ++i)\n" | 442 "for (var i = 0; i < 1; ++i)\n" |
454 " a.shift();\n"); | 443 " a.shift();\n"); |
455 | 444 |
456 HEAP->CollectAllGarbage(i::Heap::kNoGCFlags); | 445 HEAP->CollectAllGarbage(i::Heap::kNoGCFlags); |
457 | 446 |
458 const v8::HeapSnapshot* snapshot2 = | 447 const v8::HeapSnapshot* snapshot2 = |
459 heap_profiler->TakeHeapSnapshot(v8_str("s2")); | 448 v8::HeapProfiler::TakeSnapshot(v8_str("s2")); |
460 | 449 |
461 const v8::HeapGraphNode* global1 = GetGlobalObject(snapshot1); | 450 const v8::HeapGraphNode* global1 = GetGlobalObject(snapshot1); |
462 const v8::HeapGraphNode* global2 = GetGlobalObject(snapshot2); | 451 const v8::HeapGraphNode* global2 = GetGlobalObject(snapshot2); |
463 CHECK_NE_SNAPSHOT_OBJECT_ID(0, global1->GetId()); | 452 CHECK_NE_SNAPSHOT_OBJECT_ID(0, global1->GetId()); |
464 CHECK_EQ_SNAPSHOT_OBJECT_ID(global1->GetId(), global2->GetId()); | 453 CHECK_EQ_SNAPSHOT_OBJECT_ID(global1->GetId(), global2->GetId()); |
465 | 454 |
466 const v8::HeapGraphNode* a1 = | 455 const v8::HeapGraphNode* a1 = |
467 GetProperty(global1, v8::HeapGraphEdge::kProperty, "a"); | 456 GetProperty(global1, v8::HeapGraphEdge::kProperty, "a"); |
468 CHECK_NE(NULL, a1); | 457 CHECK_NE(NULL, a1); |
469 const v8::HeapGraphNode* k1 = | 458 const v8::HeapGraphNode* k1 = |
470 GetProperty(a1, v8::HeapGraphEdge::kInternal, "elements"); | 459 GetProperty(a1, v8::HeapGraphEdge::kInternal, "elements"); |
471 CHECK_NE(NULL, k1); | 460 CHECK_NE(NULL, k1); |
472 const v8::HeapGraphNode* a2 = | 461 const v8::HeapGraphNode* a2 = |
473 GetProperty(global2, v8::HeapGraphEdge::kProperty, "a"); | 462 GetProperty(global2, v8::HeapGraphEdge::kProperty, "a"); |
474 CHECK_NE(NULL, a2); | 463 CHECK_NE(NULL, a2); |
475 const v8::HeapGraphNode* k2 = | 464 const v8::HeapGraphNode* k2 = |
476 GetProperty(a2, v8::HeapGraphEdge::kInternal, "elements"); | 465 GetProperty(a2, v8::HeapGraphEdge::kInternal, "elements"); |
477 CHECK_NE(NULL, k2); | 466 CHECK_NE(NULL, k2); |
478 | 467 |
479 CHECK_EQ_SNAPSHOT_OBJECT_ID(a1->GetId(), a2->GetId()); | 468 CHECK_EQ_SNAPSHOT_OBJECT_ID(a1->GetId(), a2->GetId()); |
480 CHECK_EQ_SNAPSHOT_OBJECT_ID(k1->GetId(), k2->GetId()); | 469 CHECK_EQ_SNAPSHOT_OBJECT_ID(k1->GetId(), k2->GetId()); |
481 } | 470 } |
482 | 471 |
483 TEST(HeapEntryIdsAndGC) { | 472 TEST(HeapEntryIdsAndGC) { |
484 LocalContext env; | 473 LocalContext env; |
485 v8::HandleScope scope(env->GetIsolate()); | 474 v8::HandleScope scope(env->GetIsolate()); |
486 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
487 | 475 |
488 CompileRun( | 476 CompileRun( |
489 "function A() {}\n" | 477 "function A() {}\n" |
490 "function B(x) { this.x = x; }\n" | 478 "function B(x) { this.x = x; }\n" |
491 "var a = new A();\n" | 479 "var a = new A();\n" |
492 "var b = new B(a);"); | 480 "var b = new B(a);"); |
493 v8::Local<v8::String> s1_str = v8_str("s1"); | 481 v8::Local<v8::String> s1_str = v8_str("s1"); |
494 v8::Local<v8::String> s2_str = v8_str("s2"); | 482 v8::Local<v8::String> s2_str = v8_str("s2"); |
495 const v8::HeapSnapshot* snapshot1 = | 483 const v8::HeapSnapshot* snapshot1 = |
496 heap_profiler->TakeHeapSnapshot(s1_str); | 484 v8::HeapProfiler::TakeSnapshot(s1_str); |
497 | 485 |
498 HEAP->CollectAllGarbage(i::Heap::kNoGCFlags); | 486 HEAP->CollectAllGarbage(i::Heap::kNoGCFlags); |
499 | 487 |
500 const v8::HeapSnapshot* snapshot2 = | 488 const v8::HeapSnapshot* snapshot2 = |
501 heap_profiler->TakeHeapSnapshot(s2_str); | 489 v8::HeapProfiler::TakeSnapshot(s2_str); |
502 | 490 |
503 CHECK_GT(snapshot1->GetMaxSnapshotJSObjectId(), 7000); | 491 CHECK_GT(snapshot1->GetMaxSnapshotJSObjectId(), 7000); |
504 CHECK(snapshot1->GetMaxSnapshotJSObjectId() <= | 492 CHECK(snapshot1->GetMaxSnapshotJSObjectId() <= |
505 snapshot2->GetMaxSnapshotJSObjectId()); | 493 snapshot2->GetMaxSnapshotJSObjectId()); |
506 | 494 |
507 const v8::HeapGraphNode* global1 = GetGlobalObject(snapshot1); | 495 const v8::HeapGraphNode* global1 = GetGlobalObject(snapshot1); |
508 const v8::HeapGraphNode* global2 = GetGlobalObject(snapshot2); | 496 const v8::HeapGraphNode* global2 = GetGlobalObject(snapshot2); |
509 CHECK_NE_SNAPSHOT_OBJECT_ID(0, global1->GetId()); | 497 CHECK_NE_SNAPSHOT_OBJECT_ID(0, global1->GetId()); |
510 CHECK_EQ_SNAPSHOT_OBJECT_ID(global1->GetId(), global2->GetId()); | 498 CHECK_EQ_SNAPSHOT_OBJECT_ID(global1->GetId(), global2->GetId()); |
511 const v8::HeapGraphNode* A1 = | 499 const v8::HeapGraphNode* A1 = |
(...skipping 27 matching lines...) Expand all Loading... |
539 GetProperty(global2, v8::HeapGraphEdge::kProperty, "b"); | 527 GetProperty(global2, v8::HeapGraphEdge::kProperty, "b"); |
540 CHECK_NE(NULL, b2); | 528 CHECK_NE(NULL, b2); |
541 CHECK_NE_SNAPSHOT_OBJECT_ID(0, b1->GetId()); | 529 CHECK_NE_SNAPSHOT_OBJECT_ID(0, b1->GetId()); |
542 CHECK_EQ_SNAPSHOT_OBJECT_ID(b1->GetId(), b2->GetId()); | 530 CHECK_EQ_SNAPSHOT_OBJECT_ID(b1->GetId(), b2->GetId()); |
543 } | 531 } |
544 | 532 |
545 | 533 |
546 TEST(HeapSnapshotRootPreservedAfterSorting) { | 534 TEST(HeapSnapshotRootPreservedAfterSorting) { |
547 LocalContext env; | 535 LocalContext env; |
548 v8::HandleScope scope(env->GetIsolate()); | 536 v8::HandleScope scope(env->GetIsolate()); |
549 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
550 const v8::HeapSnapshot* snapshot = | 537 const v8::HeapSnapshot* snapshot = |
551 heap_profiler->TakeHeapSnapshot(v8_str("s")); | 538 v8::HeapProfiler::TakeSnapshot(v8_str("s")); |
552 const v8::HeapGraphNode* root1 = snapshot->GetRoot(); | 539 const v8::HeapGraphNode* root1 = snapshot->GetRoot(); |
553 const_cast<i::HeapSnapshot*>(reinterpret_cast<const i::HeapSnapshot*>( | 540 const_cast<i::HeapSnapshot*>(reinterpret_cast<const i::HeapSnapshot*>( |
554 snapshot))->GetSortedEntriesList(); | 541 snapshot))->GetSortedEntriesList(); |
555 const v8::HeapGraphNode* root2 = snapshot->GetRoot(); | 542 const v8::HeapGraphNode* root2 = snapshot->GetRoot(); |
556 CHECK_EQ(root1, root2); | 543 CHECK_EQ(root1, root2); |
557 } | 544 } |
558 | 545 |
559 | 546 |
560 namespace { | 547 namespace { |
561 | 548 |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
598 private: | 585 private: |
599 const char* data_; | 586 const char* data_; |
600 size_t length_; | 587 size_t length_; |
601 }; | 588 }; |
602 | 589 |
603 } // namespace | 590 } // namespace |
604 | 591 |
605 TEST(HeapSnapshotJSONSerialization) { | 592 TEST(HeapSnapshotJSONSerialization) { |
606 LocalContext env; | 593 LocalContext env; |
607 v8::HandleScope scope(env->GetIsolate()); | 594 v8::HandleScope scope(env->GetIsolate()); |
608 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
609 | 595 |
610 #define STRING_LITERAL_FOR_TEST \ | 596 #define STRING_LITERAL_FOR_TEST \ |
611 "\"String \\n\\r\\u0008\\u0081\\u0101\\u0801\\u8001\"" | 597 "\"String \\n\\r\\u0008\\u0081\\u0101\\u0801\\u8001\"" |
612 CompileRun( | 598 CompileRun( |
613 "function A(s) { this.s = s; }\n" | 599 "function A(s) { this.s = s; }\n" |
614 "function B(x) { this.x = x; }\n" | 600 "function B(x) { this.x = x; }\n" |
615 "var a = new A(" STRING_LITERAL_FOR_TEST ");\n" | 601 "var a = new A(" STRING_LITERAL_FOR_TEST ");\n" |
616 "var b = new B(a);"); | 602 "var b = new B(a);"); |
617 const v8::HeapSnapshot* snapshot = | 603 const v8::HeapSnapshot* snapshot = |
618 heap_profiler->TakeHeapSnapshot(v8_str("json")); | 604 v8::HeapProfiler::TakeSnapshot(v8_str("json")); |
619 TestJSONStream stream; | 605 TestJSONStream stream; |
620 snapshot->Serialize(&stream, v8::HeapSnapshot::kJSON); | 606 snapshot->Serialize(&stream, v8::HeapSnapshot::kJSON); |
621 CHECK_GT(stream.size(), 0); | 607 CHECK_GT(stream.size(), 0); |
622 CHECK_EQ(1, stream.eos_signaled()); | 608 CHECK_EQ(1, stream.eos_signaled()); |
623 i::ScopedVector<char> json(stream.size()); | 609 i::ScopedVector<char> json(stream.size()); |
624 stream.WriteTo(json); | 610 stream.WriteTo(json); |
625 | 611 |
626 // Verify that snapshot string is valid JSON. | 612 // Verify that snapshot string is valid JSON. |
627 AsciiResource json_res(json); | 613 AsciiResource json_res(json); |
628 v8::Local<v8::String> json_string = v8::String::NewExternal(&json_res); | 614 v8::Local<v8::String> json_string = v8::String::NewExternal(&json_res); |
(...skipping 72 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
701 CompileRun(STRING_LITERAL_FOR_TEST)->ToString(); | 687 CompileRun(STRING_LITERAL_FOR_TEST)->ToString(); |
702 #undef STRING_LITERAL_FOR_TEST | 688 #undef STRING_LITERAL_FOR_TEST |
703 CHECK_EQ(*v8::String::Utf8Value(ref_string), | 689 CHECK_EQ(*v8::String::Utf8Value(ref_string), |
704 *v8::String::Utf8Value(string)); | 690 *v8::String::Utf8Value(string)); |
705 } | 691 } |
706 | 692 |
707 | 693 |
708 TEST(HeapSnapshotJSONSerializationAborting) { | 694 TEST(HeapSnapshotJSONSerializationAborting) { |
709 LocalContext env; | 695 LocalContext env; |
710 v8::HandleScope scope(env->GetIsolate()); | 696 v8::HandleScope scope(env->GetIsolate()); |
711 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
712 const v8::HeapSnapshot* snapshot = | 697 const v8::HeapSnapshot* snapshot = |
713 heap_profiler->TakeHeapSnapshot(v8_str("abort")); | 698 v8::HeapProfiler::TakeSnapshot(v8_str("abort")); |
714 TestJSONStream stream(5); | 699 TestJSONStream stream(5); |
715 snapshot->Serialize(&stream, v8::HeapSnapshot::kJSON); | 700 snapshot->Serialize(&stream, v8::HeapSnapshot::kJSON); |
716 CHECK_GT(stream.size(), 0); | 701 CHECK_GT(stream.size(), 0); |
717 CHECK_EQ(0, stream.eos_signaled()); | 702 CHECK_EQ(0, stream.eos_signaled()); |
718 } | 703 } |
719 | 704 |
720 namespace { | 705 namespace { |
721 | 706 |
722 class TestStatsStream : public v8::OutputStream { | 707 class TestStatsStream : public v8::OutputStream { |
723 public: | 708 public: |
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
769 int updates_written_; | 754 int updates_written_; |
770 uint32_t entries_count_; | 755 uint32_t entries_count_; |
771 uint32_t entries_size_; | 756 uint32_t entries_size_; |
772 int intervals_count_; | 757 int intervals_count_; |
773 int first_interval_index_; | 758 int first_interval_index_; |
774 }; | 759 }; |
775 | 760 |
776 } // namespace | 761 } // namespace |
777 | 762 |
778 static TestStatsStream GetHeapStatsUpdate( | 763 static TestStatsStream GetHeapStatsUpdate( |
779 v8::HeapProfiler* heap_profiler, | |
780 v8::SnapshotObjectId* object_id = NULL) { | 764 v8::SnapshotObjectId* object_id = NULL) { |
781 TestStatsStream stream; | 765 TestStatsStream stream; |
782 v8::SnapshotObjectId last_seen_id = heap_profiler->GetHeapStats(&stream); | 766 v8::SnapshotObjectId last_seen_id = |
| 767 v8::HeapProfiler::PushHeapObjectsStats(&stream); |
783 if (object_id) | 768 if (object_id) |
784 *object_id = last_seen_id; | 769 *object_id = last_seen_id; |
785 CHECK_EQ(1, stream.eos_signaled()); | 770 CHECK_EQ(1, stream.eos_signaled()); |
786 return stream; | 771 return stream; |
787 } | 772 } |
788 | 773 |
789 | 774 |
790 TEST(HeapSnapshotObjectsStats) { | 775 TEST(HeapSnapshotObjectsStats) { |
791 LocalContext env; | 776 LocalContext env; |
792 v8::HandleScope scope(env->GetIsolate()); | 777 v8::HandleScope scope(env->GetIsolate()); |
793 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
794 | 778 |
795 heap_profiler->StartTrackingHeapObjects(); | 779 v8::HeapProfiler::StartHeapObjectsTracking(); |
796 // We have to call GC 6 times. In other case the garbage will be | 780 // We have to call GC 6 times. In other case the garbage will be |
797 // the reason of flakiness. | 781 // the reason of flakiness. |
798 for (int i = 0; i < 6; ++i) { | 782 for (int i = 0; i < 6; ++i) { |
799 HEAP->CollectAllGarbage(i::Heap::kNoGCFlags); | 783 HEAP->CollectAllGarbage(i::Heap::kNoGCFlags); |
800 } | 784 } |
801 | 785 |
802 v8::SnapshotObjectId initial_id; | 786 v8::SnapshotObjectId initial_id; |
803 { | 787 { |
804 // Single chunk of data expected in update. Initial data. | 788 // Single chunk of data expected in update. Initial data. |
805 TestStatsStream stats_update = GetHeapStatsUpdate(heap_profiler, | 789 TestStatsStream stats_update = GetHeapStatsUpdate(&initial_id); |
806 &initial_id); | |
807 CHECK_EQ(1, stats_update.intervals_count()); | 790 CHECK_EQ(1, stats_update.intervals_count()); |
808 CHECK_EQ(1, stats_update.updates_written()); | 791 CHECK_EQ(1, stats_update.updates_written()); |
809 CHECK_LT(0, stats_update.entries_size()); | 792 CHECK_LT(0, stats_update.entries_size()); |
810 CHECK_EQ(0, stats_update.first_interval_index()); | 793 CHECK_EQ(0, stats_update.first_interval_index()); |
811 } | 794 } |
812 | 795 |
813 // No data expected in update because nothing has happened. | 796 // No data expected in update because nothing has happened. |
814 v8::SnapshotObjectId same_id; | 797 v8::SnapshotObjectId same_id; |
815 CHECK_EQ(0, GetHeapStatsUpdate(heap_profiler, &same_id).updates_written()); | 798 CHECK_EQ(0, GetHeapStatsUpdate(&same_id).updates_written()); |
816 CHECK_EQ_SNAPSHOT_OBJECT_ID(initial_id, same_id); | 799 CHECK_EQ_SNAPSHOT_OBJECT_ID(initial_id, same_id); |
817 | 800 |
818 { | 801 { |
819 v8::SnapshotObjectId additional_string_id; | 802 v8::SnapshotObjectId additional_string_id; |
820 v8::HandleScope inner_scope_1(env->GetIsolate()); | 803 v8::HandleScope inner_scope_1(env->GetIsolate()); |
821 v8_str("string1"); | 804 v8_str("string1"); |
822 { | 805 { |
823 // Single chunk of data with one new entry expected in update. | 806 // Single chunk of data with one new entry expected in update. |
824 TestStatsStream stats_update = GetHeapStatsUpdate(heap_profiler, | 807 TestStatsStream stats_update = GetHeapStatsUpdate(&additional_string_id); |
825 &additional_string_id); | |
826 CHECK_LT(same_id, additional_string_id); | 808 CHECK_LT(same_id, additional_string_id); |
827 CHECK_EQ(1, stats_update.intervals_count()); | 809 CHECK_EQ(1, stats_update.intervals_count()); |
828 CHECK_EQ(1, stats_update.updates_written()); | 810 CHECK_EQ(1, stats_update.updates_written()); |
829 CHECK_LT(0, stats_update.entries_size()); | 811 CHECK_LT(0, stats_update.entries_size()); |
830 CHECK_EQ(1, stats_update.entries_count()); | 812 CHECK_EQ(1, stats_update.entries_count()); |
831 CHECK_EQ(2, stats_update.first_interval_index()); | 813 CHECK_EQ(2, stats_update.first_interval_index()); |
832 } | 814 } |
833 | 815 |
834 // No data expected in update because nothing happened. | 816 // No data expected in update because nothing happened. |
835 v8::SnapshotObjectId last_id; | 817 v8::SnapshotObjectId last_id; |
836 CHECK_EQ(0, GetHeapStatsUpdate(heap_profiler, &last_id).updates_written()); | 818 CHECK_EQ(0, GetHeapStatsUpdate(&last_id).updates_written()); |
837 CHECK_EQ_SNAPSHOT_OBJECT_ID(additional_string_id, last_id); | 819 CHECK_EQ_SNAPSHOT_OBJECT_ID(additional_string_id, last_id); |
838 | 820 |
839 { | 821 { |
840 v8::HandleScope inner_scope_2(env->GetIsolate()); | 822 v8::HandleScope inner_scope_2(env->GetIsolate()); |
841 v8_str("string2"); | 823 v8_str("string2"); |
842 | 824 |
843 uint32_t entries_size; | 825 uint32_t entries_size; |
844 { | 826 { |
845 v8::HandleScope inner_scope_3(env->GetIsolate()); | 827 v8::HandleScope inner_scope_3(env->GetIsolate()); |
846 v8_str("string3"); | 828 v8_str("string3"); |
847 v8_str("string4"); | 829 v8_str("string4"); |
848 | 830 |
849 { | 831 { |
850 // Single chunk of data with three new entries expected in update. | 832 // Single chunk of data with three new entries expected in update. |
851 TestStatsStream stats_update = GetHeapStatsUpdate(heap_profiler); | 833 TestStatsStream stats_update = GetHeapStatsUpdate(); |
852 CHECK_EQ(1, stats_update.intervals_count()); | 834 CHECK_EQ(1, stats_update.intervals_count()); |
853 CHECK_EQ(1, stats_update.updates_written()); | 835 CHECK_EQ(1, stats_update.updates_written()); |
854 CHECK_LT(0, entries_size = stats_update.entries_size()); | 836 CHECK_LT(0, entries_size = stats_update.entries_size()); |
855 CHECK_EQ(3, stats_update.entries_count()); | 837 CHECK_EQ(3, stats_update.entries_count()); |
856 CHECK_EQ(4, stats_update.first_interval_index()); | 838 CHECK_EQ(4, stats_update.first_interval_index()); |
857 } | 839 } |
858 } | 840 } |
859 | 841 |
860 { | 842 { |
861 // Single chunk of data with two left entries expected in update. | 843 // Single chunk of data with two left entries expected in update. |
862 TestStatsStream stats_update = GetHeapStatsUpdate(heap_profiler); | 844 TestStatsStream stats_update = GetHeapStatsUpdate(); |
863 CHECK_EQ(1, stats_update.intervals_count()); | 845 CHECK_EQ(1, stats_update.intervals_count()); |
864 CHECK_EQ(1, stats_update.updates_written()); | 846 CHECK_EQ(1, stats_update.updates_written()); |
865 CHECK_GT(entries_size, stats_update.entries_size()); | 847 CHECK_GT(entries_size, stats_update.entries_size()); |
866 CHECK_EQ(1, stats_update.entries_count()); | 848 CHECK_EQ(1, stats_update.entries_count()); |
867 // Two strings from forth interval were released. | 849 // Two strings from forth interval were released. |
868 CHECK_EQ(4, stats_update.first_interval_index()); | 850 CHECK_EQ(4, stats_update.first_interval_index()); |
869 } | 851 } |
870 } | 852 } |
871 | 853 |
872 { | 854 { |
873 // Single chunk of data with 0 left entries expected in update. | 855 // Single chunk of data with 0 left entries expected in update. |
874 TestStatsStream stats_update = GetHeapStatsUpdate(heap_profiler); | 856 TestStatsStream stats_update = GetHeapStatsUpdate(); |
875 CHECK_EQ(1, stats_update.intervals_count()); | 857 CHECK_EQ(1, stats_update.intervals_count()); |
876 CHECK_EQ(1, stats_update.updates_written()); | 858 CHECK_EQ(1, stats_update.updates_written()); |
877 CHECK_EQ(0, stats_update.entries_size()); | 859 CHECK_EQ(0, stats_update.entries_size()); |
878 CHECK_EQ(0, stats_update.entries_count()); | 860 CHECK_EQ(0, stats_update.entries_count()); |
879 // The last string from forth interval was released. | 861 // The last string from forth interval was released. |
880 CHECK_EQ(4, stats_update.first_interval_index()); | 862 CHECK_EQ(4, stats_update.first_interval_index()); |
881 } | 863 } |
882 } | 864 } |
883 { | 865 { |
884 // Single chunk of data with 0 left entries expected in update. | 866 // Single chunk of data with 0 left entries expected in update. |
885 TestStatsStream stats_update = GetHeapStatsUpdate(heap_profiler); | 867 TestStatsStream stats_update = GetHeapStatsUpdate(); |
886 CHECK_EQ(1, stats_update.intervals_count()); | 868 CHECK_EQ(1, stats_update.intervals_count()); |
887 CHECK_EQ(1, stats_update.updates_written()); | 869 CHECK_EQ(1, stats_update.updates_written()); |
888 CHECK_EQ(0, stats_update.entries_size()); | 870 CHECK_EQ(0, stats_update.entries_size()); |
889 CHECK_EQ(0, stats_update.entries_count()); | 871 CHECK_EQ(0, stats_update.entries_count()); |
890 // The only string from the second interval was released. | 872 // The only string from the second interval was released. |
891 CHECK_EQ(2, stats_update.first_interval_index()); | 873 CHECK_EQ(2, stats_update.first_interval_index()); |
892 } | 874 } |
893 | 875 |
894 v8::Local<v8::Array> array = v8::Array::New(); | 876 v8::Local<v8::Array> array = v8::Array::New(); |
895 CHECK_EQ(0, array->Length()); | 877 CHECK_EQ(0, array->Length()); |
896 // Force array's buffer allocation. | 878 // Force array's buffer allocation. |
897 array->Set(2, v8_num(7)); | 879 array->Set(2, v8_num(7)); |
898 | 880 |
899 uint32_t entries_size; | 881 uint32_t entries_size; |
900 { | 882 { |
901 // Single chunk of data with 2 entries expected in update. | 883 // Single chunk of data with 2 entries expected in update. |
902 TestStatsStream stats_update = GetHeapStatsUpdate(heap_profiler); | 884 TestStatsStream stats_update = GetHeapStatsUpdate(); |
903 CHECK_EQ(1, stats_update.intervals_count()); | 885 CHECK_EQ(1, stats_update.intervals_count()); |
904 CHECK_EQ(1, stats_update.updates_written()); | 886 CHECK_EQ(1, stats_update.updates_written()); |
905 CHECK_LT(0, entries_size = stats_update.entries_size()); | 887 CHECK_LT(0, entries_size = stats_update.entries_size()); |
906 // They are the array and its buffer. | 888 // They are the array and its buffer. |
907 CHECK_EQ(2, stats_update.entries_count()); | 889 CHECK_EQ(2, stats_update.entries_count()); |
908 CHECK_EQ(8, stats_update.first_interval_index()); | 890 CHECK_EQ(8, stats_update.first_interval_index()); |
909 } | 891 } |
910 | 892 |
911 for (int i = 0; i < 100; ++i) | 893 for (int i = 0; i < 100; ++i) |
912 array->Set(i, v8_num(i)); | 894 array->Set(i, v8_num(i)); |
913 | 895 |
914 { | 896 { |
915 // Single chunk of data with 1 entry expected in update. | 897 // Single chunk of data with 1 entry expected in update. |
916 TestStatsStream stats_update = GetHeapStatsUpdate(heap_profiler); | 898 TestStatsStream stats_update = GetHeapStatsUpdate(); |
917 CHECK_EQ(1, stats_update.intervals_count()); | 899 CHECK_EQ(1, stats_update.intervals_count()); |
918 // The first interval was changed because old buffer was collected. | 900 // The first interval was changed because old buffer was collected. |
919 // The second interval was changed because new buffer was allocated. | 901 // The second interval was changed because new buffer was allocated. |
920 CHECK_EQ(2, stats_update.updates_written()); | 902 CHECK_EQ(2, stats_update.updates_written()); |
921 CHECK_LT(entries_size, stats_update.entries_size()); | 903 CHECK_LT(entries_size, stats_update.entries_size()); |
922 CHECK_EQ(2, stats_update.entries_count()); | 904 CHECK_EQ(2, stats_update.entries_count()); |
923 CHECK_EQ(8, stats_update.first_interval_index()); | 905 CHECK_EQ(8, stats_update.first_interval_index()); |
924 } | 906 } |
925 | 907 |
926 heap_profiler->StopTrackingHeapObjects(); | 908 v8::HeapProfiler::StopHeapObjectsTracking(); |
927 } | 909 } |
928 | 910 |
929 | 911 |
930 static void CheckChildrenIds(const v8::HeapSnapshot* snapshot, | 912 static void CheckChildrenIds(const v8::HeapSnapshot* snapshot, |
931 const v8::HeapGraphNode* node, | 913 const v8::HeapGraphNode* node, |
932 int level, int max_level) { | 914 int level, int max_level) { |
933 if (level > max_level) return; | 915 if (level > max_level) return; |
934 CHECK_EQ(node, snapshot->GetNodeById(node->GetId())); | 916 CHECK_EQ(node, snapshot->GetNodeById(node->GetId())); |
935 for (int i = 0, count = node->GetChildrenCount(); i < count; ++i) { | 917 for (int i = 0, count = node->GetChildrenCount(); i < count; ++i) { |
936 const v8::HeapGraphEdge* prop = node->GetChild(i); | 918 const v8::HeapGraphEdge* prop = node->GetChild(i); |
937 const v8::HeapGraphNode* child = | 919 const v8::HeapGraphNode* child = |
938 snapshot->GetNodeById(prop->GetToNode()->GetId()); | 920 snapshot->GetNodeById(prop->GetToNode()->GetId()); |
939 CHECK_EQ_SNAPSHOT_OBJECT_ID(prop->GetToNode()->GetId(), child->GetId()); | 921 CHECK_EQ_SNAPSHOT_OBJECT_ID(prop->GetToNode()->GetId(), child->GetId()); |
940 CHECK_EQ(prop->GetToNode(), child); | 922 CHECK_EQ(prop->GetToNode(), child); |
941 CheckChildrenIds(snapshot, child, level + 1, max_level); | 923 CheckChildrenIds(snapshot, child, level + 1, max_level); |
942 } | 924 } |
943 } | 925 } |
944 | 926 |
945 | 927 |
946 TEST(HeapSnapshotGetNodeById) { | 928 TEST(HeapSnapshotGetNodeById) { |
947 LocalContext env; | 929 LocalContext env; |
948 v8::HandleScope scope(env->GetIsolate()); | 930 v8::HandleScope scope(env->GetIsolate()); |
949 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
950 | 931 |
951 const v8::HeapSnapshot* snapshot = | 932 const v8::HeapSnapshot* snapshot = |
952 heap_profiler->TakeHeapSnapshot(v8_str("id")); | 933 v8::HeapProfiler::TakeSnapshot(v8_str("id")); |
953 const v8::HeapGraphNode* root = snapshot->GetRoot(); | 934 const v8::HeapGraphNode* root = snapshot->GetRoot(); |
954 CheckChildrenIds(snapshot, root, 0, 3); | 935 CheckChildrenIds(snapshot, root, 0, 3); |
955 // Check a big id, which should not exist yet. | 936 // Check a big id, which should not exist yet. |
956 CHECK_EQ(NULL, snapshot->GetNodeById(0x1000000UL)); | 937 CHECK_EQ(NULL, snapshot->GetNodeById(0x1000000UL)); |
957 } | 938 } |
958 | 939 |
959 | 940 |
960 TEST(HeapSnapshotGetSnapshotObjectId) { | 941 TEST(HeapSnapshotGetSnapshotObjectId) { |
961 LocalContext env; | 942 LocalContext env; |
962 v8::HandleScope scope(env->GetIsolate()); | 943 v8::HandleScope scope(env->GetIsolate()); |
963 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
964 CompileRun("globalObject = {};\n"); | 944 CompileRun("globalObject = {};\n"); |
965 const v8::HeapSnapshot* snapshot = | 945 const v8::HeapSnapshot* snapshot = |
966 heap_profiler->TakeHeapSnapshot(v8_str("get_snapshot_object_id")); | 946 v8::HeapProfiler::TakeSnapshot(v8_str("get_snapshot_object_id")); |
967 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); | 947 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); |
968 const v8::HeapGraphNode* global_object = | 948 const v8::HeapGraphNode* global_object = |
969 GetProperty(global, v8::HeapGraphEdge::kProperty, "globalObject"); | 949 GetProperty(global, v8::HeapGraphEdge::kProperty, "globalObject"); |
970 CHECK(global_object); | 950 CHECK(global_object); |
971 | 951 |
972 v8::Local<v8::Value> globalObjectHandle = | 952 v8::Local<v8::Value> globalObjectHandle = |
973 env->Global()->Get(v8::String::New("globalObject")); | 953 env->Global()->Get(v8::String::New("globalObject")); |
974 CHECK(!globalObjectHandle.IsEmpty()); | 954 CHECK(!globalObjectHandle.IsEmpty()); |
975 CHECK(globalObjectHandle->IsObject()); | 955 CHECK(globalObjectHandle->IsObject()); |
976 | 956 |
977 v8::SnapshotObjectId id = heap_profiler->GetObjectId(globalObjectHandle); | 957 v8::SnapshotObjectId id = |
| 958 v8::HeapProfiler::GetSnapshotObjectId(globalObjectHandle); |
978 CHECK_NE(static_cast<int>(v8::HeapProfiler::kUnknownObjectId), | 959 CHECK_NE(static_cast<int>(v8::HeapProfiler::kUnknownObjectId), |
979 id); | 960 id); |
980 CHECK_EQ(static_cast<int>(id), global_object->GetId()); | 961 CHECK_EQ(static_cast<int>(id), global_object->GetId()); |
981 } | 962 } |
982 | 963 |
983 | 964 |
984 TEST(HeapSnapshotUnknownSnapshotObjectId) { | 965 TEST(HeapSnapshotUnknownSnapshotObjectId) { |
985 LocalContext env; | 966 LocalContext env; |
986 v8::HandleScope scope(env->GetIsolate()); | 967 v8::HandleScope scope(env->GetIsolate()); |
987 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
988 CompileRun("globalObject = {};\n"); | 968 CompileRun("globalObject = {};\n"); |
989 const v8::HeapSnapshot* snapshot = | 969 const v8::HeapSnapshot* snapshot = |
990 heap_profiler->TakeHeapSnapshot(v8_str("unknown_object_id")); | 970 v8::HeapProfiler::TakeSnapshot(v8_str("unknown_object_id")); |
991 const v8::HeapGraphNode* node = | 971 const v8::HeapGraphNode* node = |
992 snapshot->GetNodeById(v8::HeapProfiler::kUnknownObjectId); | 972 snapshot->GetNodeById(v8::HeapProfiler::kUnknownObjectId); |
993 CHECK_EQ(NULL, node); | 973 CHECK_EQ(NULL, node); |
994 } | 974 } |
995 | 975 |
996 | 976 |
997 namespace { | 977 namespace { |
998 | 978 |
999 class TestActivityControl : public v8::ActivityControl { | 979 class TestActivityControl : public v8::ActivityControl { |
1000 public: | 980 public: |
(...skipping 11 matching lines...) Expand all Loading... |
1012 int done_; | 992 int done_; |
1013 int total_; | 993 int total_; |
1014 int abort_count_; | 994 int abort_count_; |
1015 }; | 995 }; |
1016 } | 996 } |
1017 | 997 |
1018 TEST(TakeHeapSnapshotAborting) { | 998 TEST(TakeHeapSnapshotAborting) { |
1019 LocalContext env; | 999 LocalContext env; |
1020 v8::HandleScope scope(env->GetIsolate()); | 1000 v8::HandleScope scope(env->GetIsolate()); |
1021 | 1001 |
1022 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | 1002 const int snapshots_count = v8::HeapProfiler::GetSnapshotsCount(); |
1023 const int snapshots_count = heap_profiler->GetSnapshotCount(); | |
1024 TestActivityControl aborting_control(1); | 1003 TestActivityControl aborting_control(1); |
1025 const v8::HeapSnapshot* no_snapshot = | 1004 const v8::HeapSnapshot* no_snapshot = |
1026 heap_profiler->TakeHeapSnapshot(v8_str("abort"), | 1005 v8::HeapProfiler::TakeSnapshot(v8_str("abort"), |
| 1006 v8::HeapSnapshot::kFull, |
1027 &aborting_control); | 1007 &aborting_control); |
1028 CHECK_EQ(NULL, no_snapshot); | 1008 CHECK_EQ(NULL, no_snapshot); |
1029 CHECK_EQ(snapshots_count, heap_profiler->GetSnapshotCount()); | 1009 CHECK_EQ(snapshots_count, v8::HeapProfiler::GetSnapshotsCount()); |
1030 CHECK_GT(aborting_control.total(), aborting_control.done()); | 1010 CHECK_GT(aborting_control.total(), aborting_control.done()); |
1031 | 1011 |
1032 TestActivityControl control(-1); // Don't abort. | 1012 TestActivityControl control(-1); // Don't abort. |
1033 const v8::HeapSnapshot* snapshot = | 1013 const v8::HeapSnapshot* snapshot = |
1034 heap_profiler->TakeHeapSnapshot(v8_str("full"), | 1014 v8::HeapProfiler::TakeSnapshot(v8_str("full"), |
| 1015 v8::HeapSnapshot::kFull, |
1035 &control); | 1016 &control); |
1036 CHECK_NE(NULL, snapshot); | 1017 CHECK_NE(NULL, snapshot); |
1037 CHECK_EQ(snapshots_count + 1, heap_profiler->GetSnapshotCount()); | 1018 CHECK_EQ(snapshots_count + 1, v8::HeapProfiler::GetSnapshotsCount()); |
1038 CHECK_EQ(control.total(), control.done()); | 1019 CHECK_EQ(control.total(), control.done()); |
1039 CHECK_GT(control.total(), 0); | 1020 CHECK_GT(control.total(), 0); |
1040 } | 1021 } |
1041 | 1022 |
1042 | 1023 |
1043 namespace { | 1024 namespace { |
1044 | 1025 |
1045 class TestRetainedObjectInfo : public v8::RetainedObjectInfo { | 1026 class TestRetainedObjectInfo : public v8::RetainedObjectInfo { |
1046 public: | 1027 public: |
1047 TestRetainedObjectInfo(int hash, | 1028 TestRetainedObjectInfo(int hash, |
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1121 } | 1102 } |
1122 } | 1103 } |
1123 return NULL; | 1104 return NULL; |
1124 } | 1105 } |
1125 | 1106 |
1126 | 1107 |
1127 TEST(HeapSnapshotRetainedObjectInfo) { | 1108 TEST(HeapSnapshotRetainedObjectInfo) { |
1128 LocalContext env; | 1109 LocalContext env; |
1129 v8::Isolate* isolate = env->GetIsolate(); | 1110 v8::Isolate* isolate = env->GetIsolate(); |
1130 v8::HandleScope scope(isolate); | 1111 v8::HandleScope scope(isolate); |
1131 v8::HeapProfiler* heap_profiler = isolate->GetHeapProfiler(); | |
1132 | 1112 |
1133 heap_profiler->SetWrapperClassInfoProvider( | 1113 v8::HeapProfiler::DefineWrapperClass( |
1134 1, TestRetainedObjectInfo::WrapperInfoCallback); | 1114 1, TestRetainedObjectInfo::WrapperInfoCallback); |
1135 heap_profiler->SetWrapperClassInfoProvider( | 1115 v8::HeapProfiler::DefineWrapperClass( |
1136 2, TestRetainedObjectInfo::WrapperInfoCallback); | 1116 2, TestRetainedObjectInfo::WrapperInfoCallback); |
1137 v8::Persistent<v8::String> p_AAA = | 1117 v8::Persistent<v8::String> p_AAA = |
1138 v8::Persistent<v8::String>::New(isolate, v8_str("AAA")); | 1118 v8::Persistent<v8::String>::New(isolate, v8_str("AAA")); |
1139 p_AAA.SetWrapperClassId(isolate, 1); | 1119 p_AAA.SetWrapperClassId(isolate, 1); |
1140 v8::Persistent<v8::String> p_BBB = | 1120 v8::Persistent<v8::String> p_BBB = |
1141 v8::Persistent<v8::String>::New(isolate, v8_str("BBB")); | 1121 v8::Persistent<v8::String>::New(isolate, v8_str("BBB")); |
1142 p_BBB.SetWrapperClassId(isolate, 1); | 1122 p_BBB.SetWrapperClassId(isolate, 1); |
1143 v8::Persistent<v8::String> p_CCC = | 1123 v8::Persistent<v8::String> p_CCC = |
1144 v8::Persistent<v8::String>::New(isolate, v8_str("CCC")); | 1124 v8::Persistent<v8::String>::New(isolate, v8_str("CCC")); |
1145 p_CCC.SetWrapperClassId(isolate, 2); | 1125 p_CCC.SetWrapperClassId(isolate, 2); |
1146 CHECK_EQ(0, TestRetainedObjectInfo::instances.length()); | 1126 CHECK_EQ(0, TestRetainedObjectInfo::instances.length()); |
1147 const v8::HeapSnapshot* snapshot = | 1127 const v8::HeapSnapshot* snapshot = |
1148 heap_profiler->TakeHeapSnapshot(v8_str("retained")); | 1128 v8::HeapProfiler::TakeSnapshot(v8_str("retained")); |
1149 | 1129 |
1150 CHECK_EQ(3, TestRetainedObjectInfo::instances.length()); | 1130 CHECK_EQ(3, TestRetainedObjectInfo::instances.length()); |
1151 for (int i = 0; i < TestRetainedObjectInfo::instances.length(); ++i) { | 1131 for (int i = 0; i < TestRetainedObjectInfo::instances.length(); ++i) { |
1152 CHECK(TestRetainedObjectInfo::instances[i]->disposed()); | 1132 CHECK(TestRetainedObjectInfo::instances[i]->disposed()); |
1153 delete TestRetainedObjectInfo::instances[i]; | 1133 delete TestRetainedObjectInfo::instances[i]; |
1154 } | 1134 } |
1155 | 1135 |
1156 const v8::HeapGraphNode* native_group_aaa = GetNode( | 1136 const v8::HeapGraphNode* native_group_aaa = GetNode( |
1157 snapshot->GetRoot(), v8::HeapGraphNode::kSynthetic, "aaa-group"); | 1137 snapshot->GetRoot(), v8::HeapGraphNode::kSynthetic, "aaa-group"); |
1158 CHECK_NE(NULL, native_group_aaa); | 1138 CHECK_NE(NULL, native_group_aaa); |
(...skipping 59 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1218 v8::Persistent<v8::Value> objects_[kObjectsCount]; | 1198 v8::Persistent<v8::Value> objects_[kObjectsCount]; |
1219 static GraphWithImplicitRefs* instance_; | 1199 static GraphWithImplicitRefs* instance_; |
1220 }; | 1200 }; |
1221 | 1201 |
1222 GraphWithImplicitRefs* GraphWithImplicitRefs::instance_ = NULL; | 1202 GraphWithImplicitRefs* GraphWithImplicitRefs::instance_ = NULL; |
1223 | 1203 |
1224 | 1204 |
1225 TEST(HeapSnapshotImplicitReferences) { | 1205 TEST(HeapSnapshotImplicitReferences) { |
1226 LocalContext env; | 1206 LocalContext env; |
1227 v8::HandleScope scope(env->GetIsolate()); | 1207 v8::HandleScope scope(env->GetIsolate()); |
1228 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
1229 | 1208 |
1230 GraphWithImplicitRefs graph(&env); | 1209 GraphWithImplicitRefs graph(&env); |
1231 v8::V8::AddGCPrologueCallback(&GraphWithImplicitRefs::gcPrologue); | 1210 v8::V8::AddGCPrologueCallback(&GraphWithImplicitRefs::gcPrologue); |
1232 | 1211 |
1233 const v8::HeapSnapshot* snapshot = | 1212 const v8::HeapSnapshot* snapshot = |
1234 heap_profiler->TakeHeapSnapshot(v8_str("implicit_refs")); | 1213 v8::HeapProfiler::TakeSnapshot(v8_str("implicit_refs")); |
1235 | 1214 |
1236 const v8::HeapGraphNode* global_object = GetGlobalObject(snapshot); | 1215 const v8::HeapGraphNode* global_object = GetGlobalObject(snapshot); |
1237 const v8::HeapGraphNode* obj0 = GetProperty( | 1216 const v8::HeapGraphNode* obj0 = GetProperty( |
1238 global_object, v8::HeapGraphEdge::kProperty, "root_object"); | 1217 global_object, v8::HeapGraphEdge::kProperty, "root_object"); |
1239 CHECK(obj0); | 1218 CHECK(obj0); |
1240 CHECK_EQ(v8::HeapGraphNode::kObject, obj0->GetType()); | 1219 CHECK_EQ(v8::HeapGraphNode::kObject, obj0->GetType()); |
1241 const v8::HeapGraphNode* obj1 = GetProperty( | 1220 const v8::HeapGraphNode* obj1 = GetProperty( |
1242 obj0, v8::HeapGraphEdge::kInternal, "native"); | 1221 obj0, v8::HeapGraphEdge::kInternal, "native"); |
1243 CHECK(obj1); | 1222 CHECK(obj1); |
1244 int implicit_targets_count = 0; | 1223 int implicit_targets_count = 0; |
1245 for (int i = 0, count = obj1->GetChildrenCount(); i < count; ++i) { | 1224 for (int i = 0, count = obj1->GetChildrenCount(); i < count; ++i) { |
1246 const v8::HeapGraphEdge* prop = obj1->GetChild(i); | 1225 const v8::HeapGraphEdge* prop = obj1->GetChild(i); |
1247 v8::String::AsciiValue prop_name(prop->GetName()); | 1226 v8::String::AsciiValue prop_name(prop->GetName()); |
1248 if (prop->GetType() == v8::HeapGraphEdge::kInternal && | 1227 if (prop->GetType() == v8::HeapGraphEdge::kInternal && |
1249 strcmp("native", *prop_name) == 0) { | 1228 strcmp("native", *prop_name) == 0) { |
1250 ++implicit_targets_count; | 1229 ++implicit_targets_count; |
1251 } | 1230 } |
1252 } | 1231 } |
1253 CHECK_EQ(2, implicit_targets_count); | 1232 CHECK_EQ(2, implicit_targets_count); |
1254 v8::V8::RemoveGCPrologueCallback(&GraphWithImplicitRefs::gcPrologue); | 1233 v8::V8::RemoveGCPrologueCallback(&GraphWithImplicitRefs::gcPrologue); |
1255 } | 1234 } |
1256 | 1235 |
1257 | 1236 |
1258 TEST(DeleteAllHeapSnapshots) { | 1237 TEST(DeleteAllHeapSnapshots) { |
1259 LocalContext env; | 1238 LocalContext env; |
1260 v8::HandleScope scope(env->GetIsolate()); | 1239 v8::HandleScope scope(env->GetIsolate()); |
1261 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
1262 | 1240 |
1263 CHECK_EQ(0, heap_profiler->GetSnapshotCount()); | 1241 CHECK_EQ(0, v8::HeapProfiler::GetSnapshotsCount()); |
1264 heap_profiler->DeleteAllHeapSnapshots(); | 1242 v8::HeapProfiler::DeleteAllSnapshots(); |
1265 CHECK_EQ(0, heap_profiler->GetSnapshotCount()); | 1243 CHECK_EQ(0, v8::HeapProfiler::GetSnapshotsCount()); |
1266 CHECK_NE(NULL, heap_profiler->TakeHeapSnapshot(v8_str("1"))); | 1244 CHECK_NE(NULL, v8::HeapProfiler::TakeSnapshot(v8_str("1"))); |
1267 CHECK_EQ(1, heap_profiler->GetSnapshotCount()); | 1245 CHECK_EQ(1, v8::HeapProfiler::GetSnapshotsCount()); |
1268 heap_profiler->DeleteAllHeapSnapshots(); | 1246 v8::HeapProfiler::DeleteAllSnapshots(); |
1269 CHECK_EQ(0, heap_profiler->GetSnapshotCount()); | 1247 CHECK_EQ(0, v8::HeapProfiler::GetSnapshotsCount()); |
1270 CHECK_NE(NULL, heap_profiler->TakeHeapSnapshot(v8_str("1"))); | 1248 CHECK_NE(NULL, v8::HeapProfiler::TakeSnapshot(v8_str("1"))); |
1271 CHECK_NE(NULL, heap_profiler->TakeHeapSnapshot(v8_str("2"))); | 1249 CHECK_NE(NULL, v8::HeapProfiler::TakeSnapshot(v8_str("2"))); |
1272 CHECK_EQ(2, heap_profiler->GetSnapshotCount()); | 1250 CHECK_EQ(2, v8::HeapProfiler::GetSnapshotsCount()); |
1273 heap_profiler->DeleteAllHeapSnapshots(); | 1251 v8::HeapProfiler::DeleteAllSnapshots(); |
1274 CHECK_EQ(0, heap_profiler->GetSnapshotCount()); | 1252 CHECK_EQ(0, v8::HeapProfiler::GetSnapshotsCount()); |
1275 } | 1253 } |
1276 | 1254 |
1277 | 1255 |
1278 TEST(DeleteHeapSnapshot) { | 1256 TEST(DeleteHeapSnapshot) { |
1279 LocalContext env; | 1257 LocalContext env; |
1280 v8::HandleScope scope(env->GetIsolate()); | 1258 v8::HandleScope scope(env->GetIsolate()); |
1281 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
1282 | 1259 |
1283 CHECK_EQ(0, heap_profiler->GetSnapshotCount()); | 1260 CHECK_EQ(0, v8::HeapProfiler::GetSnapshotsCount()); |
1284 const v8::HeapSnapshot* s1 = | 1261 const v8::HeapSnapshot* s1 = |
1285 heap_profiler->TakeHeapSnapshot(v8_str("1")); | 1262 v8::HeapProfiler::TakeSnapshot(v8_str("1")); |
1286 CHECK_NE(NULL, s1); | 1263 CHECK_NE(NULL, s1); |
1287 CHECK_EQ(1, heap_profiler->GetSnapshotCount()); | 1264 CHECK_EQ(1, v8::HeapProfiler::GetSnapshotsCount()); |
1288 unsigned uid1 = s1->GetUid(); | 1265 unsigned uid1 = s1->GetUid(); |
1289 CHECK_EQ(s1, heap_profiler->FindHeapSnapshot(uid1)); | 1266 CHECK_EQ(s1, v8::HeapProfiler::FindSnapshot(uid1)); |
1290 const_cast<v8::HeapSnapshot*>(s1)->Delete(); | 1267 const_cast<v8::HeapSnapshot*>(s1)->Delete(); |
1291 CHECK_EQ(0, heap_profiler->GetSnapshotCount()); | 1268 CHECK_EQ(0, v8::HeapProfiler::GetSnapshotsCount()); |
1292 CHECK_EQ(NULL, heap_profiler->FindHeapSnapshot(uid1)); | 1269 CHECK_EQ(NULL, v8::HeapProfiler::FindSnapshot(uid1)); |
1293 | 1270 |
1294 const v8::HeapSnapshot* s2 = | 1271 const v8::HeapSnapshot* s2 = |
1295 heap_profiler->TakeHeapSnapshot(v8_str("2")); | 1272 v8::HeapProfiler::TakeSnapshot(v8_str("2")); |
1296 CHECK_NE(NULL, s2); | 1273 CHECK_NE(NULL, s2); |
1297 CHECK_EQ(1, heap_profiler->GetSnapshotCount()); | 1274 CHECK_EQ(1, v8::HeapProfiler::GetSnapshotsCount()); |
1298 unsigned uid2 = s2->GetUid(); | 1275 unsigned uid2 = s2->GetUid(); |
1299 CHECK_NE(static_cast<int>(uid1), static_cast<int>(uid2)); | 1276 CHECK_NE(static_cast<int>(uid1), static_cast<int>(uid2)); |
1300 CHECK_EQ(s2, heap_profiler->FindHeapSnapshot(uid2)); | 1277 CHECK_EQ(s2, v8::HeapProfiler::FindSnapshot(uid2)); |
1301 const v8::HeapSnapshot* s3 = | 1278 const v8::HeapSnapshot* s3 = |
1302 heap_profiler->TakeHeapSnapshot(v8_str("3")); | 1279 v8::HeapProfiler::TakeSnapshot(v8_str("3")); |
1303 CHECK_NE(NULL, s3); | 1280 CHECK_NE(NULL, s3); |
1304 CHECK_EQ(2, heap_profiler->GetSnapshotCount()); | 1281 CHECK_EQ(2, v8::HeapProfiler::GetSnapshotsCount()); |
1305 unsigned uid3 = s3->GetUid(); | 1282 unsigned uid3 = s3->GetUid(); |
1306 CHECK_NE(static_cast<int>(uid1), static_cast<int>(uid3)); | 1283 CHECK_NE(static_cast<int>(uid1), static_cast<int>(uid3)); |
1307 CHECK_EQ(s3, heap_profiler->FindHeapSnapshot(uid3)); | 1284 CHECK_EQ(s3, v8::HeapProfiler::FindSnapshot(uid3)); |
1308 const_cast<v8::HeapSnapshot*>(s2)->Delete(); | 1285 const_cast<v8::HeapSnapshot*>(s2)->Delete(); |
1309 CHECK_EQ(1, heap_profiler->GetSnapshotCount()); | 1286 CHECK_EQ(1, v8::HeapProfiler::GetSnapshotsCount()); |
1310 CHECK_EQ(NULL, heap_profiler->FindHeapSnapshot(uid2)); | 1287 CHECK_EQ(NULL, v8::HeapProfiler::FindSnapshot(uid2)); |
1311 CHECK_EQ(s3, heap_profiler->FindHeapSnapshot(uid3)); | 1288 CHECK_EQ(s3, v8::HeapProfiler::FindSnapshot(uid3)); |
1312 const_cast<v8::HeapSnapshot*>(s3)->Delete(); | 1289 const_cast<v8::HeapSnapshot*>(s3)->Delete(); |
1313 CHECK_EQ(0, heap_profiler->GetSnapshotCount()); | 1290 CHECK_EQ(0, v8::HeapProfiler::GetSnapshotsCount()); |
1314 CHECK_EQ(NULL, heap_profiler->FindHeapSnapshot(uid3)); | 1291 CHECK_EQ(NULL, v8::HeapProfiler::FindSnapshot(uid3)); |
1315 } | 1292 } |
1316 | 1293 |
1317 | 1294 |
1318 class NameResolver : public v8::HeapProfiler::ObjectNameResolver { | 1295 class NameResolver : public v8::HeapProfiler::ObjectNameResolver { |
1319 public: | 1296 public: |
1320 virtual const char* GetName(v8::Handle<v8::Object> object) { | 1297 virtual const char* GetName(v8::Handle<v8::Object> object) { |
1321 return "Global object name"; | 1298 return "Global object name"; |
1322 } | 1299 } |
1323 }; | 1300 }; |
1324 | 1301 |
1325 TEST(GlobalObjectName) { | 1302 TEST(GlobalObjectName) { |
1326 LocalContext env; | 1303 LocalContext env; |
1327 v8::HandleScope scope(env->GetIsolate()); | 1304 v8::HandleScope scope(env->GetIsolate()); |
1328 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
1329 | 1305 |
1330 CompileRun("document = { URL:\"abcdefgh\" };"); | 1306 CompileRun("document = { URL:\"abcdefgh\" };"); |
1331 | 1307 |
1332 NameResolver name_resolver; | 1308 NameResolver name_resolver; |
1333 const v8::HeapSnapshot* snapshot = | 1309 const v8::HeapSnapshot* snapshot = |
1334 heap_profiler->TakeHeapSnapshot(v8_str("document"), | 1310 v8::HeapProfiler::TakeSnapshot(v8_str("document"), |
| 1311 v8::HeapSnapshot::kFull, |
1335 NULL, | 1312 NULL, |
1336 &name_resolver); | 1313 &name_resolver); |
1337 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); | 1314 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); |
1338 CHECK_NE(NULL, global); | 1315 CHECK_NE(NULL, global); |
1339 CHECK_EQ("Object / Global object name" , | 1316 CHECK_EQ("Object / Global object name" , |
1340 const_cast<i::HeapEntry*>( | 1317 const_cast<i::HeapEntry*>( |
1341 reinterpret_cast<const i::HeapEntry*>(global))->name()); | 1318 reinterpret_cast<const i::HeapEntry*>(global))->name()); |
1342 } | 1319 } |
1343 | 1320 |
1344 | 1321 |
1345 TEST(NoHandleLeaks) { | 1322 TEST(NoHandleLeaks) { |
1346 LocalContext env; | 1323 LocalContext env; |
1347 v8::HandleScope scope(env->GetIsolate()); | 1324 v8::HandleScope scope(env->GetIsolate()); |
1348 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
1349 | 1325 |
1350 CompileRun("document = { URL:\"abcdefgh\" };"); | 1326 CompileRun("document = { URL:\"abcdefgh\" };"); |
1351 | 1327 |
1352 v8::Handle<v8::String> name(v8_str("leakz")); | 1328 v8::Handle<v8::String> name(v8_str("leakz")); |
1353 i::Isolate* isolate = i::Isolate::Current(); | 1329 i::Isolate* isolate = i::Isolate::Current(); |
1354 int count_before = i::HandleScope::NumberOfHandles(isolate); | 1330 int count_before = i::HandleScope::NumberOfHandles(isolate); |
1355 heap_profiler->TakeHeapSnapshot(name); | 1331 v8::HeapProfiler::TakeSnapshot(name); |
1356 int count_after = i::HandleScope::NumberOfHandles(isolate); | 1332 int count_after = i::HandleScope::NumberOfHandles(isolate); |
1357 CHECK_EQ(count_before, count_after); | 1333 CHECK_EQ(count_before, count_after); |
1358 } | 1334 } |
1359 | 1335 |
1360 | 1336 |
1361 TEST(NodesIteration) { | 1337 TEST(NodesIteration) { |
1362 LocalContext env; | 1338 LocalContext env; |
1363 v8::HandleScope scope(env->GetIsolate()); | 1339 v8::HandleScope scope(env->GetIsolate()); |
1364 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
1365 const v8::HeapSnapshot* snapshot = | 1340 const v8::HeapSnapshot* snapshot = |
1366 heap_profiler->TakeHeapSnapshot(v8_str("iteration")); | 1341 v8::HeapProfiler::TakeSnapshot(v8_str("iteration")); |
1367 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); | 1342 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); |
1368 CHECK_NE(NULL, global); | 1343 CHECK_NE(NULL, global); |
1369 // Verify that we can find this object by iteration. | 1344 // Verify that we can find this object by iteration. |
1370 const int nodes_count = snapshot->GetNodesCount(); | 1345 const int nodes_count = snapshot->GetNodesCount(); |
1371 int count = 0; | 1346 int count = 0; |
1372 for (int i = 0; i < nodes_count; ++i) { | 1347 for (int i = 0; i < nodes_count; ++i) { |
1373 if (snapshot->GetNode(i) == global) | 1348 if (snapshot->GetNode(i) == global) |
1374 ++count; | 1349 ++count; |
1375 } | 1350 } |
1376 CHECK_EQ(1, count); | 1351 CHECK_EQ(1, count); |
1377 } | 1352 } |
1378 | 1353 |
1379 | 1354 |
1380 TEST(GetHeapValue) { | 1355 TEST(GetHeapValue) { |
1381 LocalContext env; | 1356 LocalContext env; |
1382 v8::HandleScope scope(env->GetIsolate()); | 1357 v8::HandleScope scope(env->GetIsolate()); |
1383 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
1384 | 1358 |
1385 CompileRun("a = { s_prop: \'value\', n_prop: 0.1 };"); | 1359 CompileRun("a = { s_prop: \'value\', n_prop: 0.1 };"); |
1386 const v8::HeapSnapshot* snapshot = | 1360 const v8::HeapSnapshot* snapshot = |
1387 heap_profiler->TakeHeapSnapshot(v8_str("value")); | 1361 v8::HeapProfiler::TakeSnapshot(v8_str("value")); |
1388 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); | 1362 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); |
1389 CHECK(global->GetHeapValue()->IsObject()); | 1363 CHECK(global->GetHeapValue()->IsObject()); |
1390 v8::Local<v8::Object> js_global = | 1364 v8::Local<v8::Object> js_global = |
1391 env->Global()->GetPrototype().As<v8::Object>(); | 1365 env->Global()->GetPrototype().As<v8::Object>(); |
1392 CHECK(js_global == global->GetHeapValue()); | 1366 CHECK(js_global == global->GetHeapValue()); |
1393 const v8::HeapGraphNode* obj = GetProperty( | 1367 const v8::HeapGraphNode* obj = GetProperty( |
1394 global, v8::HeapGraphEdge::kProperty, "a"); | 1368 global, v8::HeapGraphEdge::kProperty, "a"); |
1395 CHECK(obj->GetHeapValue()->IsObject()); | 1369 CHECK(obj->GetHeapValue()->IsObject()); |
1396 v8::Local<v8::Object> js_obj = js_global->Get(v8_str("a")).As<v8::Object>(); | 1370 v8::Local<v8::Object> js_obj = js_global->Get(v8_str("a")).As<v8::Object>(); |
1397 CHECK(js_obj == obj->GetHeapValue()); | 1371 CHECK(js_obj == obj->GetHeapValue()); |
1398 const v8::HeapGraphNode* s_prop = | 1372 const v8::HeapGraphNode* s_prop = |
1399 GetProperty(obj, v8::HeapGraphEdge::kProperty, "s_prop"); | 1373 GetProperty(obj, v8::HeapGraphEdge::kProperty, "s_prop"); |
1400 v8::Local<v8::String> js_s_prop = | 1374 v8::Local<v8::String> js_s_prop = |
1401 js_obj->Get(v8_str("s_prop")).As<v8::String>(); | 1375 js_obj->Get(v8_str("s_prop")).As<v8::String>(); |
1402 CHECK(js_s_prop == s_prop->GetHeapValue()); | 1376 CHECK(js_s_prop == s_prop->GetHeapValue()); |
1403 const v8::HeapGraphNode* n_prop = | 1377 const v8::HeapGraphNode* n_prop = |
1404 GetProperty(obj, v8::HeapGraphEdge::kProperty, "n_prop"); | 1378 GetProperty(obj, v8::HeapGraphEdge::kProperty, "n_prop"); |
1405 v8::Local<v8::Number> js_n_prop = | 1379 v8::Local<v8::Number> js_n_prop = |
1406 js_obj->Get(v8_str("n_prop")).As<v8::Number>(); | 1380 js_obj->Get(v8_str("n_prop")).As<v8::Number>(); |
1407 CHECK(js_n_prop == n_prop->GetHeapValue()); | 1381 CHECK(js_n_prop == n_prop->GetHeapValue()); |
1408 } | 1382 } |
1409 | 1383 |
1410 | 1384 |
1411 TEST(GetHeapValueForDeletedObject) { | 1385 TEST(GetHeapValueForDeletedObject) { |
1412 LocalContext env; | 1386 LocalContext env; |
1413 v8::HandleScope scope(env->GetIsolate()); | 1387 v8::HandleScope scope(env->GetIsolate()); |
1414 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
1415 | 1388 |
1416 // It is impossible to delete a global property, so we are about to delete a | 1389 // It is impossible to delete a global property, so we are about to delete a |
1417 // property of the "a" object. Also, the "p" object can't be an empty one | 1390 // property of the "a" object. Also, the "p" object can't be an empty one |
1418 // because the empty object is static and isn't actually deleted. | 1391 // because the empty object is static and isn't actually deleted. |
1419 CompileRun("a = { p: { r: {} } };"); | 1392 CompileRun("a = { p: { r: {} } };"); |
1420 const v8::HeapSnapshot* snapshot = | 1393 const v8::HeapSnapshot* snapshot = |
1421 heap_profiler->TakeHeapSnapshot(v8_str("snapshot")); | 1394 v8::HeapProfiler::TakeSnapshot(v8_str("snapshot")); |
1422 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); | 1395 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); |
1423 const v8::HeapGraphNode* obj = GetProperty( | 1396 const v8::HeapGraphNode* obj = GetProperty( |
1424 global, v8::HeapGraphEdge::kProperty, "a"); | 1397 global, v8::HeapGraphEdge::kProperty, "a"); |
1425 const v8::HeapGraphNode* prop = GetProperty( | 1398 const v8::HeapGraphNode* prop = GetProperty( |
1426 obj, v8::HeapGraphEdge::kProperty, "p"); | 1399 obj, v8::HeapGraphEdge::kProperty, "p"); |
1427 { | 1400 { |
1428 // Perform the check inside a nested local scope to avoid creating a | 1401 // Perform the check inside a nested local scope to avoid creating a |
1429 // reference to the object we are deleting. | 1402 // reference to the object we are deleting. |
1430 v8::HandleScope scope(env->GetIsolate()); | 1403 v8::HandleScope scope(env->GetIsolate()); |
1431 CHECK(prop->GetHeapValue()->IsObject()); | 1404 CHECK(prop->GetHeapValue()->IsObject()); |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1487 v8::Local<v8::Object> obj6 = js_global->Get(v8_str("obj6")).As<v8::Object>(); | 1460 v8::Local<v8::Object> obj6 = js_global->Get(v8_str("obj6")).As<v8::Object>(); |
1488 i::Handle<i::JSObject> js_obj6 = v8::Utils::OpenHandle(*obj6); | 1461 i::Handle<i::JSObject> js_obj6 = v8::Utils::OpenHandle(*obj6); |
1489 CHECK_EQ(0, StringCmp( | 1462 CHECK_EQ(0, StringCmp( |
1490 "Object", i::V8HeapExplorer::GetConstructorName(*js_obj6))); | 1463 "Object", i::V8HeapExplorer::GetConstructorName(*js_obj6))); |
1491 } | 1464 } |
1492 | 1465 |
1493 | 1466 |
1494 TEST(FastCaseGetter) { | 1467 TEST(FastCaseGetter) { |
1495 LocalContext env; | 1468 LocalContext env; |
1496 v8::HandleScope scope(env->GetIsolate()); | 1469 v8::HandleScope scope(env->GetIsolate()); |
1497 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
1498 | 1470 |
1499 CompileRun("var obj1 = {};\n" | 1471 CompileRun("var obj1 = {};\n" |
1500 "obj1.__defineGetter__('propWithGetter', function Y() {\n" | 1472 "obj1.__defineGetter__('propWithGetter', function Y() {\n" |
1501 " return 42;\n" | 1473 " return 42;\n" |
1502 "});\n" | 1474 "});\n" |
1503 "obj1.__defineSetter__('propWithSetter', function Z(value) {\n" | 1475 "obj1.__defineSetter__('propWithSetter', function Z(value) {\n" |
1504 " return this.value_ = value;\n" | 1476 " return this.value_ = value;\n" |
1505 "});\n"); | 1477 "});\n"); |
1506 const v8::HeapSnapshot* snapshot = | 1478 const v8::HeapSnapshot* snapshot = |
1507 heap_profiler->TakeHeapSnapshot(v8_str("fastCaseGetter")); | 1479 v8::HeapProfiler::TakeSnapshot(v8_str("fastCaseGetter")); |
1508 | 1480 |
1509 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); | 1481 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); |
1510 CHECK_NE(NULL, global); | 1482 CHECK_NE(NULL, global); |
1511 const v8::HeapGraphNode* obj1 = | 1483 const v8::HeapGraphNode* obj1 = |
1512 GetProperty(global, v8::HeapGraphEdge::kProperty, "obj1"); | 1484 GetProperty(global, v8::HeapGraphEdge::kProperty, "obj1"); |
1513 CHECK_NE(NULL, obj1); | 1485 CHECK_NE(NULL, obj1); |
1514 const v8::HeapGraphNode* getterFunction = | 1486 const v8::HeapGraphNode* getterFunction = |
1515 GetProperty(obj1, v8::HeapGraphEdge::kProperty, "get-propWithGetter"); | 1487 GetProperty(obj1, v8::HeapGraphEdge::kProperty, "get-propWithGetter"); |
1516 CHECK_NE(NULL, getterFunction); | 1488 CHECK_NE(NULL, getterFunction); |
1517 const v8::HeapGraphNode* setterFunction = | 1489 const v8::HeapGraphNode* setterFunction = |
1518 GetProperty(obj1, v8::HeapGraphEdge::kProperty, "set-propWithSetter"); | 1490 GetProperty(obj1, v8::HeapGraphEdge::kProperty, "set-propWithSetter"); |
1519 CHECK_NE(NULL, setterFunction); | 1491 CHECK_NE(NULL, setterFunction); |
1520 } | 1492 } |
1521 | 1493 |
1522 TEST(HiddenPropertiesFastCase) { | 1494 TEST(HiddenPropertiesFastCase) { |
1523 LocalContext env; | 1495 LocalContext env; |
1524 v8::HandleScope scope(env->GetIsolate()); | 1496 v8::HandleScope scope(env->GetIsolate()); |
1525 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
1526 | 1497 |
1527 CompileRun( | 1498 CompileRun( |
1528 "function C(x) { this.a = this; this.b = x; }\n" | 1499 "function C(x) { this.a = this; this.b = x; }\n" |
1529 "c = new C(2012);\n"); | 1500 "c = new C(2012);\n"); |
1530 const v8::HeapSnapshot* snapshot = | 1501 const v8::HeapSnapshot* snapshot = |
1531 heap_profiler->TakeHeapSnapshot(v8_str("HiddenPropertiesFastCase1")); | 1502 v8::HeapProfiler::TakeSnapshot(v8_str("HiddenPropertiesFastCase1")); |
1532 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); | 1503 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); |
1533 const v8::HeapGraphNode* c = | 1504 const v8::HeapGraphNode* c = |
1534 GetProperty(global, v8::HeapGraphEdge::kProperty, "c"); | 1505 GetProperty(global, v8::HeapGraphEdge::kProperty, "c"); |
1535 CHECK_NE(NULL, c); | 1506 CHECK_NE(NULL, c); |
1536 const v8::HeapGraphNode* hidden_props = | 1507 const v8::HeapGraphNode* hidden_props = |
1537 GetProperty(c, v8::HeapGraphEdge::kInternal, "hidden_properties"); | 1508 GetProperty(c, v8::HeapGraphEdge::kInternal, "hidden_properties"); |
1538 CHECK_EQ(NULL, hidden_props); | 1509 CHECK_EQ(NULL, hidden_props); |
1539 | 1510 |
1540 v8::Handle<v8::Value> cHandle = env->Global()->Get(v8::String::New("c")); | 1511 v8::Handle<v8::Value> cHandle = env->Global()->Get(v8::String::New("c")); |
1541 CHECK(!cHandle.IsEmpty() && cHandle->IsObject()); | 1512 CHECK(!cHandle.IsEmpty() && cHandle->IsObject()); |
1542 cHandle->ToObject()->SetHiddenValue(v8_str("key"), v8_str("val")); | 1513 cHandle->ToObject()->SetHiddenValue(v8_str("key"), v8_str("val")); |
1543 | 1514 |
1544 snapshot = heap_profiler->TakeHeapSnapshot( | 1515 snapshot = v8::HeapProfiler::TakeSnapshot( |
1545 v8_str("HiddenPropertiesFastCase2")); | 1516 v8_str("HiddenPropertiesFastCase2")); |
1546 global = GetGlobalObject(snapshot); | 1517 global = GetGlobalObject(snapshot); |
1547 c = GetProperty(global, v8::HeapGraphEdge::kProperty, "c"); | 1518 c = GetProperty(global, v8::HeapGraphEdge::kProperty, "c"); |
1548 CHECK_NE(NULL, c); | 1519 CHECK_NE(NULL, c); |
1549 hidden_props = GetProperty(c, v8::HeapGraphEdge::kInternal, | 1520 hidden_props = GetProperty(c, v8::HeapGraphEdge::kInternal, |
1550 "hidden_properties"); | 1521 "hidden_properties"); |
1551 CHECK_NE(NULL, hidden_props); | 1522 CHECK_NE(NULL, hidden_props); |
1552 } | 1523 } |
1553 | 1524 |
1554 bool HasWeakEdge(const v8::HeapGraphNode* node) { | 1525 bool HasWeakEdge(const v8::HeapGraphNode* node) { |
1555 for (int i = 0; i < node->GetChildrenCount(); ++i) { | 1526 for (int i = 0; i < node->GetChildrenCount(); ++i) { |
1556 const v8::HeapGraphEdge* handle_edge = node->GetChild(i); | 1527 const v8::HeapGraphEdge* handle_edge = node->GetChild(i); |
1557 if (handle_edge->GetType() == v8::HeapGraphEdge::kWeak) return true; | 1528 if (handle_edge->GetType() == v8::HeapGraphEdge::kWeak) return true; |
1558 } | 1529 } |
1559 return false; | 1530 return false; |
1560 } | 1531 } |
1561 | 1532 |
1562 | 1533 |
1563 bool HasWeakGlobalHandle() { | 1534 bool HasWeakGlobalHandle() { |
1564 v8::Isolate* isolate = v8::Isolate::GetCurrent(); | |
1565 v8::HeapProfiler* heap_profiler = isolate->GetHeapProfiler(); | |
1566 const v8::HeapSnapshot* snapshot = | 1535 const v8::HeapSnapshot* snapshot = |
1567 heap_profiler->TakeHeapSnapshot(v8_str("weaks")); | 1536 v8::HeapProfiler::TakeSnapshot(v8_str("weaks")); |
1568 const v8::HeapGraphNode* gc_roots = GetNode( | 1537 const v8::HeapGraphNode* gc_roots = GetNode( |
1569 snapshot->GetRoot(), v8::HeapGraphNode::kObject, "(GC roots)"); | 1538 snapshot->GetRoot(), v8::HeapGraphNode::kObject, "(GC roots)"); |
1570 CHECK_NE(NULL, gc_roots); | 1539 CHECK_NE(NULL, gc_roots); |
1571 const v8::HeapGraphNode* global_handles = GetNode( | 1540 const v8::HeapGraphNode* global_handles = GetNode( |
1572 gc_roots, v8::HeapGraphNode::kObject, "(Global handles)"); | 1541 gc_roots, v8::HeapGraphNode::kObject, "(Global handles)"); |
1573 CHECK_NE(NULL, global_handles); | 1542 CHECK_NE(NULL, global_handles); |
1574 return HasWeakEdge(global_handles); | 1543 return HasWeakEdge(global_handles); |
1575 } | 1544 } |
1576 | 1545 |
1577 | 1546 |
(...skipping 14 matching lines...) Expand all Loading... |
1592 v8::Persistent<v8::Object>::New(env->GetIsolate(), v8::Object::New()); | 1561 v8::Persistent<v8::Object>::New(env->GetIsolate(), v8::Object::New()); |
1593 handle.MakeWeak(env->GetIsolate(), NULL, PersistentHandleCallback); | 1562 handle.MakeWeak(env->GetIsolate(), NULL, PersistentHandleCallback); |
1594 | 1563 |
1595 CHECK(HasWeakGlobalHandle()); | 1564 CHECK(HasWeakGlobalHandle()); |
1596 } | 1565 } |
1597 | 1566 |
1598 | 1567 |
1599 TEST(WeakNativeContextRefs) { | 1568 TEST(WeakNativeContextRefs) { |
1600 LocalContext env; | 1569 LocalContext env; |
1601 v8::HandleScope scope(env->GetIsolate()); | 1570 v8::HandleScope scope(env->GetIsolate()); |
1602 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
1603 | 1571 |
1604 const v8::HeapSnapshot* snapshot = | 1572 const v8::HeapSnapshot* snapshot = |
1605 heap_profiler->TakeHeapSnapshot(v8_str("weaks")); | 1573 v8::HeapProfiler::TakeSnapshot(v8_str("weaks")); |
1606 const v8::HeapGraphNode* gc_roots = GetNode( | 1574 const v8::HeapGraphNode* gc_roots = GetNode( |
1607 snapshot->GetRoot(), v8::HeapGraphNode::kObject, "(GC roots)"); | 1575 snapshot->GetRoot(), v8::HeapGraphNode::kObject, "(GC roots)"); |
1608 CHECK_NE(NULL, gc_roots); | 1576 CHECK_NE(NULL, gc_roots); |
1609 const v8::HeapGraphNode* global_handles = GetNode( | 1577 const v8::HeapGraphNode* global_handles = GetNode( |
1610 gc_roots, v8::HeapGraphNode::kObject, "(Global handles)"); | 1578 gc_roots, v8::HeapGraphNode::kObject, "(Global handles)"); |
1611 CHECK_NE(NULL, global_handles); | 1579 CHECK_NE(NULL, global_handles); |
1612 const v8::HeapGraphNode* native_context = GetNode( | 1580 const v8::HeapGraphNode* native_context = GetNode( |
1613 global_handles, v8::HeapGraphNode::kHidden, "system / NativeContext"); | 1581 global_handles, v8::HeapGraphNode::kHidden, "system / NativeContext"); |
1614 CHECK_NE(NULL, native_context); | 1582 CHECK_NE(NULL, native_context); |
1615 CHECK(HasWeakEdge(native_context)); | 1583 CHECK(HasWeakEdge(native_context)); |
1616 } | 1584 } |
1617 | 1585 |
1618 | 1586 |
1619 TEST(SfiAndJsFunctionWeakRefs) { | 1587 TEST(SfiAndJsFunctionWeakRefs) { |
1620 LocalContext env; | 1588 LocalContext env; |
1621 v8::HandleScope scope(env->GetIsolate()); | 1589 v8::HandleScope scope(env->GetIsolate()); |
1622 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
1623 | 1590 |
1624 CompileRun( | 1591 CompileRun( |
1625 "fun = (function (x) { return function () { return x + 1; } })(1);"); | 1592 "fun = (function (x) { return function () { return x + 1; } })(1);"); |
1626 const v8::HeapSnapshot* snapshot = | 1593 const v8::HeapSnapshot* snapshot = |
1627 heap_profiler->TakeHeapSnapshot(v8_str("fun")); | 1594 v8::HeapProfiler::TakeSnapshot(v8_str("fun")); |
1628 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); | 1595 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); |
1629 CHECK_NE(NULL, global); | 1596 CHECK_NE(NULL, global); |
1630 const v8::HeapGraphNode* fun = | 1597 const v8::HeapGraphNode* fun = |
1631 GetProperty(global, v8::HeapGraphEdge::kProperty, "fun"); | 1598 GetProperty(global, v8::HeapGraphEdge::kProperty, "fun"); |
1632 CHECK(HasWeakEdge(fun)); | 1599 CHECK(HasWeakEdge(fun)); |
1633 const v8::HeapGraphNode* shared = | 1600 const v8::HeapGraphNode* shared = |
1634 GetProperty(fun, v8::HeapGraphEdge::kInternal, "shared"); | 1601 GetProperty(fun, v8::HeapGraphEdge::kInternal, "shared"); |
1635 CHECK(HasWeakEdge(shared)); | 1602 CHECK(HasWeakEdge(shared)); |
1636 } | 1603 } |
1637 | 1604 |
1638 | 1605 |
1639 #ifdef ENABLE_DEBUGGER_SUPPORT | 1606 #ifdef ENABLE_DEBUGGER_SUPPORT |
1640 TEST(NoDebugObjectInSnapshot) { | 1607 TEST(NoDebugObjectInSnapshot) { |
1641 LocalContext env; | 1608 LocalContext env; |
1642 v8::HandleScope scope(env->GetIsolate()); | 1609 v8::HandleScope scope(env->GetIsolate()); |
1643 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
1644 | 1610 |
1645 v8::internal::Isolate::Current()->debug()->Load(); | 1611 v8::internal::Isolate::Current()->debug()->Load(); |
1646 CompileRun("foo = {};"); | 1612 CompileRun("foo = {};"); |
1647 const v8::HeapSnapshot* snapshot = | 1613 const v8::HeapSnapshot* snapshot = |
1648 heap_profiler->TakeHeapSnapshot(v8_str("snapshot")); | 1614 v8::HeapProfiler::TakeSnapshot(v8_str("snapshot")); |
1649 const v8::HeapGraphNode* root = snapshot->GetRoot(); | 1615 const v8::HeapGraphNode* root = snapshot->GetRoot(); |
1650 int globals_count = 0; | 1616 int globals_count = 0; |
1651 for (int i = 0; i < root->GetChildrenCount(); ++i) { | 1617 for (int i = 0; i < root->GetChildrenCount(); ++i) { |
1652 const v8::HeapGraphEdge* edge = root->GetChild(i); | 1618 const v8::HeapGraphEdge* edge = root->GetChild(i); |
1653 if (edge->GetType() == v8::HeapGraphEdge::kShortcut) { | 1619 if (edge->GetType() == v8::HeapGraphEdge::kShortcut) { |
1654 ++globals_count; | 1620 ++globals_count; |
1655 const v8::HeapGraphNode* global = edge->GetToNode(); | 1621 const v8::HeapGraphNode* global = edge->GetToNode(); |
1656 const v8::HeapGraphNode* foo = | 1622 const v8::HeapGraphNode* foo = |
1657 GetProperty(global, v8::HeapGraphEdge::kProperty, "foo"); | 1623 GetProperty(global, v8::HeapGraphEdge::kProperty, "foo"); |
1658 CHECK_NE(NULL, foo); | 1624 CHECK_NE(NULL, foo); |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1694 CHECK_EQ(global_handle_count + 1, | 1660 CHECK_EQ(global_handle_count + 1, |
1695 v8::HeapProfiler::GetPersistentHandleCount()); | 1661 v8::HeapProfiler::GetPersistentHandleCount()); |
1696 p_BBB.Dispose(env->GetIsolate()); | 1662 p_BBB.Dispose(env->GetIsolate()); |
1697 CHECK_EQ(global_handle_count, v8::HeapProfiler::GetPersistentHandleCount()); | 1663 CHECK_EQ(global_handle_count, v8::HeapProfiler::GetPersistentHandleCount()); |
1698 } | 1664 } |
1699 | 1665 |
1700 | 1666 |
1701 TEST(AllStrongGcRootsHaveNames) { | 1667 TEST(AllStrongGcRootsHaveNames) { |
1702 LocalContext env; | 1668 LocalContext env; |
1703 v8::HandleScope scope(env->GetIsolate()); | 1669 v8::HandleScope scope(env->GetIsolate()); |
1704 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
1705 | 1670 |
1706 CompileRun("foo = {};"); | 1671 CompileRun("foo = {};"); |
1707 const v8::HeapSnapshot* snapshot = | 1672 const v8::HeapSnapshot* snapshot = |
1708 heap_profiler->TakeHeapSnapshot(v8_str("snapshot")); | 1673 v8::HeapProfiler::TakeSnapshot(v8_str("snapshot")); |
1709 const v8::HeapGraphNode* gc_roots = GetNode( | 1674 const v8::HeapGraphNode* gc_roots = GetNode( |
1710 snapshot->GetRoot(), v8::HeapGraphNode::kObject, "(GC roots)"); | 1675 snapshot->GetRoot(), v8::HeapGraphNode::kObject, "(GC roots)"); |
1711 CHECK_NE(NULL, gc_roots); | 1676 CHECK_NE(NULL, gc_roots); |
1712 const v8::HeapGraphNode* strong_roots = GetNode( | 1677 const v8::HeapGraphNode* strong_roots = GetNode( |
1713 gc_roots, v8::HeapGraphNode::kObject, "(Strong roots)"); | 1678 gc_roots, v8::HeapGraphNode::kObject, "(Strong roots)"); |
1714 CHECK_NE(NULL, strong_roots); | 1679 CHECK_NE(NULL, strong_roots); |
1715 for (int i = 0; i < strong_roots->GetChildrenCount(); ++i) { | 1680 for (int i = 0; i < strong_roots->GetChildrenCount(); ++i) { |
1716 const v8::HeapGraphEdge* edge = strong_roots->GetChild(i); | 1681 const v8::HeapGraphEdge* edge = strong_roots->GetChild(i); |
1717 CHECK_EQ(v8::HeapGraphEdge::kInternal, edge->GetType()); | 1682 CHECK_EQ(v8::HeapGraphEdge::kInternal, edge->GetType()); |
1718 v8::String::AsciiValue name(edge->GetName()); | 1683 v8::String::AsciiValue name(edge->GetName()); |
1719 CHECK(isalpha(**name)); | 1684 CHECK(isalpha(**name)); |
1720 } | 1685 } |
1721 } | 1686 } |
1722 | 1687 |
1723 | 1688 |
1724 TEST(NoRefsToNonEssentialEntries) { | 1689 TEST(NoRefsToNonEssentialEntries) { |
1725 LocalContext env; | 1690 LocalContext env; |
1726 v8::HandleScope scope(env->GetIsolate()); | 1691 v8::HandleScope scope(env->GetIsolate()); |
1727 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
1728 CompileRun("global_object = {};\n"); | 1692 CompileRun("global_object = {};\n"); |
1729 const v8::HeapSnapshot* snapshot = | 1693 const v8::HeapSnapshot* snapshot = |
1730 heap_profiler->TakeHeapSnapshot(v8_str("snapshot")); | 1694 v8::HeapProfiler::TakeSnapshot(v8_str("snapshot")); |
1731 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); | 1695 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); |
1732 const v8::HeapGraphNode* global_object = | 1696 const v8::HeapGraphNode* global_object = |
1733 GetProperty(global, v8::HeapGraphEdge::kProperty, "global_object"); | 1697 GetProperty(global, v8::HeapGraphEdge::kProperty, "global_object"); |
1734 CHECK_NE(NULL, global_object); | 1698 CHECK_NE(NULL, global_object); |
1735 const v8::HeapGraphNode* properties = | 1699 const v8::HeapGraphNode* properties = |
1736 GetProperty(global_object, v8::HeapGraphEdge::kInternal, "properties"); | 1700 GetProperty(global_object, v8::HeapGraphEdge::kInternal, "properties"); |
1737 CHECK_EQ(NULL, properties); | 1701 CHECK_EQ(NULL, properties); |
1738 const v8::HeapGraphNode* elements = | 1702 const v8::HeapGraphNode* elements = |
1739 GetProperty(global_object, v8::HeapGraphEdge::kInternal, "elements"); | 1703 GetProperty(global_object, v8::HeapGraphEdge::kInternal, "elements"); |
1740 CHECK_EQ(NULL, elements); | 1704 CHECK_EQ(NULL, elements); |
1741 } | 1705 } |
1742 | 1706 |
1743 | 1707 |
1744 TEST(MapHasDescriptorsAndTransitions) { | 1708 TEST(MapHasDescriptorsAndTransitions) { |
1745 LocalContext env; | 1709 LocalContext env; |
1746 v8::HandleScope scope(env->GetIsolate()); | 1710 v8::HandleScope scope(env->GetIsolate()); |
1747 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
1748 CompileRun("obj = { a: 10 };\n"); | 1711 CompileRun("obj = { a: 10 };\n"); |
1749 const v8::HeapSnapshot* snapshot = | 1712 const v8::HeapSnapshot* snapshot = |
1750 heap_profiler->TakeHeapSnapshot(v8_str("snapshot")); | 1713 v8::HeapProfiler::TakeSnapshot(v8_str("snapshot")); |
1751 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); | 1714 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); |
1752 const v8::HeapGraphNode* global_object = | 1715 const v8::HeapGraphNode* global_object = |
1753 GetProperty(global, v8::HeapGraphEdge::kProperty, "obj"); | 1716 GetProperty(global, v8::HeapGraphEdge::kProperty, "obj"); |
1754 CHECK_NE(NULL, global_object); | 1717 CHECK_NE(NULL, global_object); |
1755 | 1718 |
1756 const v8::HeapGraphNode* map = | 1719 const v8::HeapGraphNode* map = |
1757 GetProperty(global_object, v8::HeapGraphEdge::kInternal, "map"); | 1720 GetProperty(global_object, v8::HeapGraphEdge::kInternal, "map"); |
1758 CHECK_NE(NULL, map); | 1721 CHECK_NE(NULL, map); |
1759 const v8::HeapGraphNode* own_descriptors = GetProperty( | 1722 const v8::HeapGraphNode* own_descriptors = GetProperty( |
1760 map, v8::HeapGraphEdge::kInternal, "descriptors"); | 1723 map, v8::HeapGraphEdge::kInternal, "descriptors"); |
1761 CHECK_NE(NULL, own_descriptors); | 1724 CHECK_NE(NULL, own_descriptors); |
1762 const v8::HeapGraphNode* own_transitions = GetProperty( | 1725 const v8::HeapGraphNode* own_transitions = GetProperty( |
1763 map, v8::HeapGraphEdge::kInternal, "transitions"); | 1726 map, v8::HeapGraphEdge::kInternal, "transitions"); |
1764 CHECK_EQ(NULL, own_transitions); | 1727 CHECK_EQ(NULL, own_transitions); |
1765 } | 1728 } |
1766 | 1729 |
1767 | 1730 |
1768 TEST(ManyLocalsInSharedContext) { | 1731 TEST(ManyLocalsInSharedContext) { |
| 1732 v8::HandleScope scope; |
1769 LocalContext env; | 1733 LocalContext env; |
1770 v8::HandleScope scope(env->GetIsolate()); | |
1771 v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler(); | |
1772 int num_objects = 6000; | 1734 int num_objects = 6000; |
1773 CompileRun( | 1735 CompileRun( |
1774 "var n = 6000;" | 1736 "var n = 6000;" |
1775 "var result = [];" | 1737 "var result = [];" |
1776 "result.push('(function outer() {');" | 1738 "result.push('(function outer() {');" |
1777 "for (var i = 0; i < n; i++) {" | 1739 "for (var i = 0; i < n; i++) {" |
1778 " var f = 'function f_' + i + '() { ';" | 1740 " var f = 'function f_' + i + '() { ';" |
1779 " if (i > 0)" | 1741 " if (i > 0)" |
1780 " f += 'f_' + (i - 1) + '();';" | 1742 " f += 'f_' + (i - 1) + '();';" |
1781 " f += ' }';" | 1743 " f += ' }';" |
1782 " result.push(f);" | 1744 " result.push(f);" |
1783 "}" | 1745 "}" |
1784 "result.push('return f_' + (n - 1) + ';');" | 1746 "result.push('return f_' + (n - 1) + ';');" |
1785 "result.push('})()');" | 1747 "result.push('})()');" |
1786 "var ok = eval(result.join('\\n'));"); | 1748 "var ok = eval(result.join('\\n'));"); |
1787 const v8::HeapSnapshot* snapshot = | 1749 const v8::HeapSnapshot* snapshot = |
1788 heap_profiler->TakeHeapSnapshot(v8_str("snapshot")); | 1750 v8::HeapProfiler::TakeSnapshot(v8_str("snapshot")); |
1789 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); | 1751 const v8::HeapGraphNode* global = GetGlobalObject(snapshot); |
1790 CHECK_NE(NULL, global); | 1752 CHECK_NE(NULL, global); |
1791 const v8::HeapGraphNode* ok_object = | 1753 const v8::HeapGraphNode* ok_object = |
1792 GetProperty(global, v8::HeapGraphEdge::kProperty, "ok"); | 1754 GetProperty(global, v8::HeapGraphEdge::kProperty, "ok"); |
1793 CHECK_NE(NULL, ok_object); | 1755 CHECK_NE(NULL, ok_object); |
1794 const v8::HeapGraphNode* context_object = | 1756 const v8::HeapGraphNode* context_object = |
1795 GetProperty(ok_object, v8::HeapGraphEdge::kInternal, "context"); | 1757 GetProperty(ok_object, v8::HeapGraphEdge::kInternal, "context"); |
1796 CHECK_NE(NULL, context_object); | 1758 CHECK_NE(NULL, context_object); |
1797 // Check the objects are not duplicated in the context. | 1759 // Check the objects are not duplicated in the context. |
1798 CHECK_EQ(v8::internal::Context::MIN_CONTEXT_SLOTS + num_objects - 1, | 1760 CHECK_EQ(v8::internal::Context::MIN_CONTEXT_SLOTS + num_objects - 1, |
1799 context_object->GetChildrenCount()); | 1761 context_object->GetChildrenCount()); |
1800 // Check all the objects have got their names. | 1762 // Check all the objects have got their names. |
1801 // ... well check just every 8th because otherwise it's too slow in debug. | 1763 // ... well check just every 8th because otherwise it's too slow in debug. |
1802 for (int i = 0; i < num_objects - 1; i += 8) { | 1764 for (int i = 0; i < num_objects - 1; i += 8) { |
1803 i::EmbeddedVector<char, 100> var_name; | 1765 i::EmbeddedVector<char, 100> var_name; |
1804 i::OS::SNPrintF(var_name, "f_%d", i); | 1766 i::OS::SNPrintF(var_name, "f_%d", i); |
1805 const v8::HeapGraphNode* f_object = GetProperty( | 1767 const v8::HeapGraphNode* f_object = GetProperty( |
1806 context_object, v8::HeapGraphEdge::kContextVariable, var_name.start()); | 1768 context_object, v8::HeapGraphEdge::kContextVariable, var_name.start()); |
1807 CHECK_NE(NULL, f_object); | 1769 CHECK_NE(NULL, f_object); |
1808 } | 1770 } |
1809 } | 1771 } |
OLD | NEW |