Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(118)

Side by Side Diff: test/cctest/test-heap-profiler.cc

Issue 12475016: Maintain API compatibility with older versions of V8. (Closed) Base URL: https://v8.googlecode.com/svn/branches/bleeding_edge
Patch Set: Created 7 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « test/cctest/test-cpu-profiler.cc ('k') | test/cctest/test-profile-generator.cc » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
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
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
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
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
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
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
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
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
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
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
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
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
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
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 }
OLDNEW
« no previous file with comments | « test/cctest/test-cpu-profiler.cc ('k') | test/cctest/test-profile-generator.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698