OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 // Test of classes in the tracked_objects.h classes. | 5 // Test of classes in the tracked_objects.h classes. |
6 | 6 |
7 #include "base/tracked_objects.h" | 7 #include "base/tracked_objects.h" |
8 | 8 |
9 #include <stddef.h> | 9 #include <stddef.h> |
10 #include <stdint.h> | 10 #include <stdint.h> |
11 | 11 |
12 #include <memory> | 12 #include <memory> |
13 | 13 |
14 #include "base/process/process_handle.h" | 14 #include "base/process/process_handle.h" |
15 #include "base/time/time.h" | 15 #include "base/time/time.h" |
16 #include "base/tracking_info.h" | 16 #include "base/tracking_info.h" |
17 #include "testing/gtest/include/gtest/gtest.h" | 17 #include "testing/gtest/include/gtest/gtest.h" |
18 | 18 |
19 const int kLineNumber = 1776; | 19 const int kLineNumber = 1776; |
20 const char kFile[] = "FixedUnitTestFileName"; | 20 const char kFile[] = "FixedUnitTestFileName"; |
21 const char kWorkerThreadName[] = "WorkerThread-1"; | 21 const char kWorkerThreadName[] = "WorkerThread-1"; |
22 const char kMainThreadName[] = "SomeMainThreadName"; | 22 const char kMainThreadName[] = "SomeMainThreadName"; |
23 const char kStillAlive[] = "Still_Alive"; | 23 const char kStillAlive[] = "Still_Alive"; |
24 | 24 |
| 25 const int32_t kAllocOps = 23; |
| 26 const int32_t kFreeOps = 27; |
| 27 const int32_t kAllocatedBytes = 59934; |
| 28 const int32_t kFreedBytes = 2 * kAllocatedBytes; |
| 29 const int32_t kAllocOverheadBytes = kAllocOps * 8; |
| 30 const int32_t kMaxAllocatedBytes = kAllocatedBytes / 2; |
| 31 |
25 namespace tracked_objects { | 32 namespace tracked_objects { |
26 | 33 |
27 class TrackedObjectsTest : public testing::Test { | 34 class TrackedObjectsTest : public testing::Test { |
28 protected: | 35 protected: |
29 TrackedObjectsTest() { | 36 TrackedObjectsTest() { |
30 // On entry, leak any database structures in case they are still in use by | 37 // On entry, leak any database structures in case they are still in use by |
31 // prior threads. | 38 // prior threads. |
32 ThreadData::ShutdownSingleThreadedCleanup(true); | 39 ThreadData::ShutdownSingleThreadedCleanup(true); |
33 | 40 |
34 test_time_ = 0; | 41 test_time_ = 0; |
(...skipping 195 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
230 EXPECT_EQ(time_elapsed, | 237 EXPECT_EQ(time_elapsed, |
231 process_data_phase.tasks[0].death_data.run_duration_max); | 238 process_data_phase.tasks[0].death_data.run_duration_max); |
232 EXPECT_EQ(time_elapsed, | 239 EXPECT_EQ(time_elapsed, |
233 process_data_phase.tasks[0].death_data.run_duration_sample); | 240 process_data_phase.tasks[0].death_data.run_duration_sample); |
234 EXPECT_EQ(0, process_data_phase.tasks[0].death_data.queue_duration_sum); | 241 EXPECT_EQ(0, process_data_phase.tasks[0].death_data.queue_duration_sum); |
235 EXPECT_EQ(0, process_data_phase.tasks[0].death_data.queue_duration_max); | 242 EXPECT_EQ(0, process_data_phase.tasks[0].death_data.queue_duration_max); |
236 EXPECT_EQ(0, process_data_phase.tasks[0].death_data.queue_duration_sample); | 243 EXPECT_EQ(0, process_data_phase.tasks[0].death_data.queue_duration_sample); |
237 EXPECT_EQ(kWorkerThreadName, process_data_phase.tasks[0].death_thread_name); | 244 EXPECT_EQ(kWorkerThreadName, process_data_phase.tasks[0].death_thread_name); |
238 } | 245 } |
239 | 246 |
240 TEST_F(TrackedObjectsTest, DeathDataTestRecordDeath) { | 247 TEST_F(TrackedObjectsTest, DeathDataTestRecordDurations) { |
241 ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE); | 248 ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE); |
242 | 249 |
243 std::unique_ptr<DeathData> data(new DeathData()); | 250 std::unique_ptr<DeathData> data(new DeathData()); |
244 ASSERT_NE(data, nullptr); | 251 ASSERT_NE(data, nullptr); |
245 EXPECT_EQ(data->run_duration_sum(), 0); | 252 EXPECT_EQ(data->run_duration_sum(), 0); |
246 EXPECT_EQ(data->run_duration_max(), 0); | 253 EXPECT_EQ(data->run_duration_max(), 0); |
247 EXPECT_EQ(data->run_duration_sample(), 0); | 254 EXPECT_EQ(data->run_duration_sample(), 0); |
248 EXPECT_EQ(data->queue_duration_sum(), 0); | 255 EXPECT_EQ(data->queue_duration_sum(), 0); |
249 EXPECT_EQ(data->queue_duration_max(), 0); | 256 EXPECT_EQ(data->queue_duration_max(), 0); |
250 EXPECT_EQ(data->queue_duration_sample(), 0); | 257 EXPECT_EQ(data->queue_duration_sample(), 0); |
251 EXPECT_EQ(data->count(), 0); | 258 EXPECT_EQ(data->count(), 0); |
252 EXPECT_EQ(nullptr, data->last_phase_snapshot()); | 259 EXPECT_EQ(nullptr, data->last_phase_snapshot()); |
253 | 260 |
254 int32_t run_ms = 42; | 261 int32_t run_ms = 42; |
255 int32_t queue_ms = 8; | 262 int32_t queue_ms = 8; |
256 | 263 |
257 const int kUnrandomInt = 0; // Fake random int that ensure we sample data. | 264 const int kUnrandomInt = 0; // Fake random int that ensure we sample data. |
258 data->RecordDeath(queue_ms, run_ms, kUnrandomInt); | 265 data->RecordDurations(queue_ms, run_ms, kUnrandomInt); |
259 EXPECT_EQ(data->run_duration_sum(), run_ms); | 266 EXPECT_EQ(data->run_duration_sum(), run_ms); |
260 EXPECT_EQ(data->run_duration_max(), run_ms); | 267 EXPECT_EQ(data->run_duration_max(), run_ms); |
261 EXPECT_EQ(data->run_duration_sample(), run_ms); | 268 EXPECT_EQ(data->run_duration_sample(), run_ms); |
262 EXPECT_EQ(data->queue_duration_sum(), queue_ms); | 269 EXPECT_EQ(data->queue_duration_sum(), queue_ms); |
263 EXPECT_EQ(data->queue_duration_max(), queue_ms); | 270 EXPECT_EQ(data->queue_duration_max(), queue_ms); |
264 EXPECT_EQ(data->queue_duration_sample(), queue_ms); | 271 EXPECT_EQ(data->queue_duration_sample(), queue_ms); |
265 EXPECT_EQ(data->count(), 1); | 272 EXPECT_EQ(data->count(), 1); |
266 EXPECT_EQ(nullptr, data->last_phase_snapshot()); | 273 EXPECT_EQ(nullptr, data->last_phase_snapshot()); |
267 | 274 |
268 data->RecordDeath(queue_ms, run_ms, kUnrandomInt); | 275 data->RecordDurations(queue_ms, run_ms, kUnrandomInt); |
269 EXPECT_EQ(data->run_duration_sum(), run_ms + run_ms); | 276 EXPECT_EQ(data->run_duration_sum(), run_ms + run_ms); |
270 EXPECT_EQ(data->run_duration_max(), run_ms); | 277 EXPECT_EQ(data->run_duration_max(), run_ms); |
271 EXPECT_EQ(data->run_duration_sample(), run_ms); | 278 EXPECT_EQ(data->run_duration_sample(), run_ms); |
272 EXPECT_EQ(data->queue_duration_sum(), queue_ms + queue_ms); | 279 EXPECT_EQ(data->queue_duration_sum(), queue_ms + queue_ms); |
273 EXPECT_EQ(data->queue_duration_max(), queue_ms); | 280 EXPECT_EQ(data->queue_duration_max(), queue_ms); |
274 EXPECT_EQ(data->queue_duration_sample(), queue_ms); | 281 EXPECT_EQ(data->queue_duration_sample(), queue_ms); |
275 EXPECT_EQ(data->count(), 2); | 282 EXPECT_EQ(data->count(), 2); |
276 EXPECT_EQ(nullptr, data->last_phase_snapshot()); | 283 EXPECT_EQ(nullptr, data->last_phase_snapshot()); |
277 } | 284 } |
278 | 285 |
| 286 TEST_F(TrackedObjectsTest, DeathDataTestRecordAllocations) { |
| 287 ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE); |
| 288 |
| 289 std::unique_ptr<DeathData> data(new DeathData()); |
| 290 ASSERT_NE(data, nullptr); |
| 291 |
| 292 EXPECT_EQ(data->alloc_ops(), 0); |
| 293 EXPECT_EQ(data->free_ops(), 0); |
| 294 EXPECT_EQ(data->allocated_bytes(), 0); |
| 295 EXPECT_EQ(data->freed_bytes(), 0); |
| 296 EXPECT_EQ(data->alloc_overhead_bytes(), 0); |
| 297 EXPECT_EQ(data->max_allocated_bytes(), 0); |
| 298 |
| 299 EXPECT_EQ(nullptr, data->last_phase_snapshot()); |
| 300 |
| 301 data->RecordAllocations(kAllocOps, kFreeOps, kAllocatedBytes, kFreedBytes, |
| 302 kAllocOverheadBytes, kMaxAllocatedBytes); |
| 303 EXPECT_EQ(data->alloc_ops(), kAllocOps); |
| 304 EXPECT_EQ(data->free_ops(), kFreeOps); |
| 305 EXPECT_EQ(data->allocated_bytes(), kAllocatedBytes); |
| 306 EXPECT_EQ(data->freed_bytes(), kFreedBytes); |
| 307 EXPECT_EQ(data->alloc_overhead_bytes(), kAllocOverheadBytes); |
| 308 EXPECT_EQ(data->max_allocated_bytes(), kMaxAllocatedBytes); |
| 309 |
| 310 // Record another batch, with a smaller max. |
| 311 const int32_t kSmallerMaxAllocatedBytes = kMaxAllocatedBytes / 2; |
| 312 data->RecordAllocations(kAllocOps, kFreeOps, kAllocatedBytes, kFreedBytes, |
| 313 kAllocOverheadBytes, kSmallerMaxAllocatedBytes); |
| 314 EXPECT_EQ(data->alloc_ops(), 2 * kAllocOps); |
| 315 EXPECT_EQ(data->free_ops(), 2 * kFreeOps); |
| 316 EXPECT_EQ(data->allocated_bytes(), 2 * kAllocatedBytes); |
| 317 EXPECT_EQ(data->freed_bytes(), 2 * kFreedBytes); |
| 318 EXPECT_EQ(data->alloc_overhead_bytes(), 2 * kAllocOverheadBytes); |
| 319 EXPECT_EQ(data->max_allocated_bytes(), kMaxAllocatedBytes); |
| 320 |
| 321 // Now with a larger max. |
| 322 const int32_t kLargerMaxAllocatedBytes = kMaxAllocatedBytes * 2; |
| 323 data->RecordAllocations(kAllocOps, kFreeOps, kAllocatedBytes, kFreedBytes, |
| 324 kAllocOverheadBytes, kLargerMaxAllocatedBytes); |
| 325 EXPECT_EQ(data->alloc_ops(), 3 * kAllocOps); |
| 326 EXPECT_EQ(data->free_ops(), 3 * kFreeOps); |
| 327 EXPECT_EQ(data->allocated_bytes(), 3 * kAllocatedBytes); |
| 328 EXPECT_EQ(data->freed_bytes(), 3 * kFreedBytes); |
| 329 EXPECT_EQ(data->alloc_overhead_bytes(), 3 * kAllocOverheadBytes); |
| 330 EXPECT_EQ(data->max_allocated_bytes(), kLargerMaxAllocatedBytes); |
| 331 |
| 332 // Saturate everything. |
| 333 data->RecordAllocations(INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX); |
| 334 EXPECT_EQ(data->alloc_ops(), INT_MAX); |
| 335 EXPECT_EQ(data->free_ops(), INT_MAX); |
| 336 EXPECT_EQ(data->allocated_bytes(), INT_MAX); |
| 337 EXPECT_EQ(data->freed_bytes(), INT_MAX); |
| 338 EXPECT_EQ(data->alloc_overhead_bytes(), INT_MAX); |
| 339 EXPECT_EQ(data->max_allocated_bytes(), INT_MAX); |
| 340 } |
| 341 |
279 TEST_F(TrackedObjectsTest, DeathDataTest2Phases) { | 342 TEST_F(TrackedObjectsTest, DeathDataTest2Phases) { |
280 ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE); | 343 ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE); |
281 | 344 |
282 std::unique_ptr<DeathData> data(new DeathData()); | 345 std::unique_ptr<DeathData> data(new DeathData()); |
283 ASSERT_NE(data, nullptr); | 346 ASSERT_NE(data, nullptr); |
284 | 347 |
285 int32_t run_ms = 42; | 348 const int32_t run_ms = 42; |
286 int32_t queue_ms = 8; | 349 const int32_t queue_ms = 8; |
287 | 350 |
288 const int kUnrandomInt = 0; // Fake random int that ensure we sample data. | 351 const int kUnrandomInt = 0; // Fake random int that ensure we sample data. |
289 data->RecordDeath(queue_ms, run_ms, kUnrandomInt); | 352 data->RecordDurations(queue_ms, run_ms, kUnrandomInt); |
290 data->RecordDeath(queue_ms, run_ms, kUnrandomInt); | 353 data->RecordDurations(queue_ms, run_ms, kUnrandomInt); |
| 354 |
| 355 data->RecordAllocations(kAllocOps, kFreeOps, kAllocatedBytes, kFreedBytes, |
| 356 kAllocOverheadBytes, kMaxAllocatedBytes); |
291 | 357 |
292 data->OnProfilingPhaseCompleted(123); | 358 data->OnProfilingPhaseCompleted(123); |
293 EXPECT_EQ(data->run_duration_sum(), run_ms + run_ms); | 359 EXPECT_EQ(data->run_duration_sum(), run_ms + run_ms); |
294 EXPECT_EQ(data->run_duration_max(), 0); | 360 EXPECT_EQ(data->run_duration_max(), 0); |
295 EXPECT_EQ(data->run_duration_sample(), run_ms); | 361 EXPECT_EQ(data->run_duration_sample(), run_ms); |
296 EXPECT_EQ(data->queue_duration_sum(), queue_ms + queue_ms); | 362 EXPECT_EQ(data->queue_duration_sum(), queue_ms + queue_ms); |
297 EXPECT_EQ(data->queue_duration_max(), 0); | 363 EXPECT_EQ(data->queue_duration_max(), 0); |
298 EXPECT_EQ(data->queue_duration_sample(), queue_ms); | 364 EXPECT_EQ(data->queue_duration_sample(), queue_ms); |
299 EXPECT_EQ(data->count(), 2); | 365 EXPECT_EQ(data->count(), 2); |
| 366 |
| 367 EXPECT_EQ(data->alloc_ops(), kAllocOps); |
| 368 EXPECT_EQ(data->free_ops(), kFreeOps); |
| 369 EXPECT_EQ(data->allocated_bytes(), kAllocatedBytes); |
| 370 EXPECT_EQ(data->freed_bytes(), kFreedBytes); |
| 371 EXPECT_EQ(data->alloc_overhead_bytes(), kAllocOverheadBytes); |
| 372 EXPECT_EQ(data->max_allocated_bytes(), kMaxAllocatedBytes); |
| 373 |
300 ASSERT_NE(nullptr, data->last_phase_snapshot()); | 374 ASSERT_NE(nullptr, data->last_phase_snapshot()); |
301 EXPECT_EQ(123, data->last_phase_snapshot()->profiling_phase); | 375 EXPECT_EQ(123, data->last_phase_snapshot()->profiling_phase); |
302 EXPECT_EQ(2, data->last_phase_snapshot()->death_data.count); | 376 EXPECT_EQ(2, data->last_phase_snapshot()->death_data.count); |
303 EXPECT_EQ(2 * run_ms, | 377 EXPECT_EQ(2 * run_ms, |
304 data->last_phase_snapshot()->death_data.run_duration_sum); | 378 data->last_phase_snapshot()->death_data.run_duration_sum); |
305 EXPECT_EQ(run_ms, data->last_phase_snapshot()->death_data.run_duration_max); | 379 EXPECT_EQ(run_ms, data->last_phase_snapshot()->death_data.run_duration_max); |
306 EXPECT_EQ(run_ms, | 380 EXPECT_EQ(run_ms, |
307 data->last_phase_snapshot()->death_data.run_duration_sample); | 381 data->last_phase_snapshot()->death_data.run_duration_sample); |
308 EXPECT_EQ(2 * queue_ms, | 382 EXPECT_EQ(2 * queue_ms, |
309 data->last_phase_snapshot()->death_data.queue_duration_sum); | 383 data->last_phase_snapshot()->death_data.queue_duration_sum); |
310 EXPECT_EQ(queue_ms, | 384 EXPECT_EQ(queue_ms, |
311 data->last_phase_snapshot()->death_data.queue_duration_max); | 385 data->last_phase_snapshot()->death_data.queue_duration_max); |
312 EXPECT_EQ(queue_ms, | 386 EXPECT_EQ(queue_ms, |
313 data->last_phase_snapshot()->death_data.queue_duration_sample); | 387 data->last_phase_snapshot()->death_data.queue_duration_sample); |
| 388 |
| 389 EXPECT_EQ(kAllocOps, data->last_phase_snapshot()->death_data.alloc_ops); |
| 390 EXPECT_EQ(kFreeOps, data->last_phase_snapshot()->death_data.free_ops); |
| 391 EXPECT_EQ(kAllocatedBytes, |
| 392 data->last_phase_snapshot()->death_data.allocated_bytes); |
| 393 EXPECT_EQ(kFreedBytes, data->last_phase_snapshot()->death_data.freed_bytes); |
| 394 EXPECT_EQ(kAllocOverheadBytes, |
| 395 data->last_phase_snapshot()->death_data.alloc_overhead_bytes); |
| 396 EXPECT_EQ(kMaxAllocatedBytes, |
| 397 data->last_phase_snapshot()->death_data.max_allocated_bytes); |
| 398 |
314 EXPECT_EQ(nullptr, data->last_phase_snapshot()->prev); | 399 EXPECT_EQ(nullptr, data->last_phase_snapshot()->prev); |
315 | 400 |
316 int32_t run_ms1 = 21; | 401 const int32_t run_ms1 = 21; |
317 int32_t queue_ms1 = 4; | 402 const int32_t queue_ms1 = 4; |
318 | 403 |
319 data->RecordDeath(queue_ms1, run_ms1, kUnrandomInt); | 404 data->RecordDurations(queue_ms1, run_ms1, kUnrandomInt); |
| 405 data->RecordAllocations(kAllocOps, kFreeOps, kAllocatedBytes, kFreedBytes, |
| 406 kAllocOverheadBytes, kMaxAllocatedBytes); |
| 407 |
320 EXPECT_EQ(data->run_duration_sum(), run_ms + run_ms + run_ms1); | 408 EXPECT_EQ(data->run_duration_sum(), run_ms + run_ms + run_ms1); |
321 EXPECT_EQ(data->run_duration_max(), run_ms1); | 409 EXPECT_EQ(data->run_duration_max(), run_ms1); |
322 EXPECT_EQ(data->run_duration_sample(), run_ms1); | 410 EXPECT_EQ(data->run_duration_sample(), run_ms1); |
323 EXPECT_EQ(data->queue_duration_sum(), queue_ms + queue_ms + queue_ms1); | 411 EXPECT_EQ(data->queue_duration_sum(), queue_ms + queue_ms + queue_ms1); |
324 EXPECT_EQ(data->queue_duration_max(), queue_ms1); | 412 EXPECT_EQ(data->queue_duration_max(), queue_ms1); |
325 EXPECT_EQ(data->queue_duration_sample(), queue_ms1); | 413 EXPECT_EQ(data->queue_duration_sample(), queue_ms1); |
326 EXPECT_EQ(data->count(), 3); | 414 EXPECT_EQ(data->count(), 3); |
| 415 |
| 416 EXPECT_EQ(data->alloc_ops(), 2 * kAllocOps); |
| 417 EXPECT_EQ(data->free_ops(), 2 * kFreeOps); |
| 418 EXPECT_EQ(data->allocated_bytes(), 2 * kAllocatedBytes); |
| 419 EXPECT_EQ(data->freed_bytes(), 2 * kFreedBytes); |
| 420 EXPECT_EQ(data->alloc_overhead_bytes(), 2 * kAllocOverheadBytes); |
| 421 EXPECT_EQ(data->max_allocated_bytes(), kMaxAllocatedBytes); |
| 422 |
327 ASSERT_NE(nullptr, data->last_phase_snapshot()); | 423 ASSERT_NE(nullptr, data->last_phase_snapshot()); |
328 EXPECT_EQ(123, data->last_phase_snapshot()->profiling_phase); | 424 EXPECT_EQ(123, data->last_phase_snapshot()->profiling_phase); |
329 EXPECT_EQ(2, data->last_phase_snapshot()->death_data.count); | 425 EXPECT_EQ(2, data->last_phase_snapshot()->death_data.count); |
330 EXPECT_EQ(2 * run_ms, | 426 EXPECT_EQ(2 * run_ms, |
331 data->last_phase_snapshot()->death_data.run_duration_sum); | 427 data->last_phase_snapshot()->death_data.run_duration_sum); |
332 EXPECT_EQ(run_ms, data->last_phase_snapshot()->death_data.run_duration_max); | 428 EXPECT_EQ(run_ms, data->last_phase_snapshot()->death_data.run_duration_max); |
333 EXPECT_EQ(run_ms, | 429 EXPECT_EQ(run_ms, |
334 data->last_phase_snapshot()->death_data.run_duration_sample); | 430 data->last_phase_snapshot()->death_data.run_duration_sample); |
335 EXPECT_EQ(2 * queue_ms, | 431 EXPECT_EQ(2 * queue_ms, |
336 data->last_phase_snapshot()->death_data.queue_duration_sum); | 432 data->last_phase_snapshot()->death_data.queue_duration_sum); |
337 EXPECT_EQ(queue_ms, | 433 EXPECT_EQ(queue_ms, |
338 data->last_phase_snapshot()->death_data.queue_duration_max); | 434 data->last_phase_snapshot()->death_data.queue_duration_max); |
339 EXPECT_EQ(queue_ms, | 435 EXPECT_EQ(queue_ms, |
340 data->last_phase_snapshot()->death_data.queue_duration_sample); | 436 data->last_phase_snapshot()->death_data.queue_duration_sample); |
| 437 |
| 438 EXPECT_EQ(kAllocOps, data->last_phase_snapshot()->death_data.alloc_ops); |
| 439 EXPECT_EQ(kFreeOps, data->last_phase_snapshot()->death_data.free_ops); |
| 440 EXPECT_EQ(kAllocatedBytes, |
| 441 data->last_phase_snapshot()->death_data.allocated_bytes); |
| 442 EXPECT_EQ(kFreedBytes, data->last_phase_snapshot()->death_data.freed_bytes); |
| 443 EXPECT_EQ(kAllocOverheadBytes, |
| 444 data->last_phase_snapshot()->death_data.alloc_overhead_bytes); |
| 445 EXPECT_EQ(kMaxAllocatedBytes, |
| 446 data->last_phase_snapshot()->death_data.max_allocated_bytes); |
| 447 |
341 EXPECT_EQ(nullptr, data->last_phase_snapshot()->prev); | 448 EXPECT_EQ(nullptr, data->last_phase_snapshot()->prev); |
342 } | 449 } |
343 | 450 |
344 TEST_F(TrackedObjectsTest, Delta) { | 451 TEST_F(TrackedObjectsTest, Delta) { |
345 ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE); | 452 ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE); |
346 | 453 |
347 DeathDataSnapshot snapshot; | 454 DeathDataSnapshot snapshot; |
348 snapshot.count = 10; | 455 snapshot.count = 10; |
349 snapshot.run_duration_sum = 100; | 456 snapshot.run_duration_sum = 100; |
350 snapshot.run_duration_max = 50; | 457 snapshot.run_duration_max = 50; |
351 snapshot.run_duration_sample = 25; | 458 snapshot.run_duration_sample = 25; |
352 snapshot.queue_duration_sum = 200; | 459 snapshot.queue_duration_sum = 200; |
353 snapshot.queue_duration_max = 101; | 460 snapshot.queue_duration_max = 101; |
354 snapshot.queue_duration_sample = 26; | 461 snapshot.queue_duration_sample = 26; |
355 | 462 |
| 463 snapshot.alloc_ops = 95; |
| 464 snapshot.free_ops = 90; |
| 465 snapshot.allocated_bytes = 10240; |
| 466 snapshot.freed_bytes = 4096; |
| 467 snapshot.alloc_overhead_bytes = 950; |
| 468 snapshot.max_allocated_bytes = 10240; |
| 469 |
356 DeathDataSnapshot older_snapshot; | 470 DeathDataSnapshot older_snapshot; |
357 older_snapshot.count = 2; | 471 older_snapshot.count = 2; |
358 older_snapshot.run_duration_sum = 95; | 472 older_snapshot.run_duration_sum = 95; |
359 older_snapshot.run_duration_max = 48; | 473 older_snapshot.run_duration_max = 48; |
360 older_snapshot.run_duration_sample = 22; | 474 older_snapshot.run_duration_sample = 22; |
361 older_snapshot.queue_duration_sum = 190; | 475 older_snapshot.queue_duration_sum = 190; |
362 older_snapshot.queue_duration_max = 99; | 476 older_snapshot.queue_duration_max = 99; |
363 older_snapshot.queue_duration_sample = 21; | 477 older_snapshot.queue_duration_sample = 21; |
364 | 478 |
| 479 older_snapshot.alloc_ops = 45; |
| 480 older_snapshot.free_ops = 40; |
| 481 older_snapshot.allocated_bytes = 4096; |
| 482 older_snapshot.freed_bytes = 2048; |
| 483 older_snapshot.alloc_overhead_bytes = 450; |
| 484 older_snapshot.max_allocated_bytes = 10200; |
| 485 |
365 const DeathDataSnapshot& delta = snapshot.Delta(older_snapshot); | 486 const DeathDataSnapshot& delta = snapshot.Delta(older_snapshot); |
366 EXPECT_EQ(8, delta.count); | 487 EXPECT_EQ(8, delta.count); |
367 EXPECT_EQ(5, delta.run_duration_sum); | 488 EXPECT_EQ(5, delta.run_duration_sum); |
368 EXPECT_EQ(50, delta.run_duration_max); | 489 EXPECT_EQ(50, delta.run_duration_max); |
369 EXPECT_EQ(25, delta.run_duration_sample); | 490 EXPECT_EQ(25, delta.run_duration_sample); |
370 EXPECT_EQ(10, delta.queue_duration_sum); | 491 EXPECT_EQ(10, delta.queue_duration_sum); |
371 EXPECT_EQ(101, delta.queue_duration_max); | 492 EXPECT_EQ(101, delta.queue_duration_max); |
372 EXPECT_EQ(26, delta.queue_duration_sample); | 493 EXPECT_EQ(26, delta.queue_duration_sample); |
| 494 |
| 495 EXPECT_EQ(50, delta.alloc_ops); |
| 496 EXPECT_EQ(50, delta.free_ops); |
| 497 EXPECT_EQ(6144, delta.allocated_bytes); |
| 498 EXPECT_EQ(2048, delta.freed_bytes); |
| 499 EXPECT_EQ(500, delta.alloc_overhead_bytes); |
| 500 EXPECT_EQ(10240, delta.max_allocated_bytes); |
373 } | 501 } |
374 | 502 |
375 TEST_F(TrackedObjectsTest, DeactivatedBirthOnlyToSnapshotWorkerThread) { | 503 TEST_F(TrackedObjectsTest, DeactivatedBirthOnlyToSnapshotWorkerThread) { |
376 // Start in the deactivated state. | 504 // Start in the deactivated state. |
377 ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED); | 505 ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED); |
378 | 506 |
379 const char kFunction[] = "DeactivatedBirthOnlyToSnapshotWorkerThread"; | 507 const char kFunction[] = "DeactivatedBirthOnlyToSnapshotWorkerThread"; |
380 Location location(kFunction, kFile, kLineNumber, NULL); | 508 Location location(kFunction, kFile, kLineNumber, NULL); |
381 TallyABirth(location, std::string()); | 509 TallyABirth(location, std::string()); |
382 | 510 |
(...skipping 795 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1178 EXPECT_EQ(2, process_data_phase.tasks[t1].death_data.run_duration_max); | 1306 EXPECT_EQ(2, process_data_phase.tasks[t1].death_data.run_duration_max); |
1179 EXPECT_EQ(2, process_data_phase.tasks[t1].death_data.run_duration_sample); | 1307 EXPECT_EQ(2, process_data_phase.tasks[t1].death_data.run_duration_sample); |
1180 EXPECT_EQ(1, process_data_phase.tasks[t1].death_data.queue_duration_sum); | 1308 EXPECT_EQ(1, process_data_phase.tasks[t1].death_data.queue_duration_sum); |
1181 EXPECT_EQ(1, process_data_phase.tasks[t1].death_data.queue_duration_max); | 1309 EXPECT_EQ(1, process_data_phase.tasks[t1].death_data.queue_duration_max); |
1182 EXPECT_EQ(1, process_data_phase.tasks[t1].death_data.queue_duration_sample); | 1310 EXPECT_EQ(1, process_data_phase.tasks[t1].death_data.queue_duration_sample); |
1183 EXPECT_EQ(kMainThreadName, process_data_phase.tasks[t1].death_thread_name); | 1311 EXPECT_EQ(kMainThreadName, process_data_phase.tasks[t1].death_thread_name); |
1184 EXPECT_EQ(base::GetCurrentProcId(), process_data.process_id); | 1312 EXPECT_EQ(base::GetCurrentProcId(), process_data.process_id); |
1185 } | 1313 } |
1186 | 1314 |
1187 } // namespace tracked_objects | 1315 } // namespace tracked_objects |
OLD | NEW |