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
3 // found in the LICENSE file.
5 // Test of classes in the tracked_objects.h classes.
7 #include "base/tracked_objects.h"
11 #include "base/memory/scoped_ptr.h"
12 #include "base/process/process_handle.h"
13 #include "base/time/time.h"
14 #include "base/tracking_info.h"
15 #include "testing/gtest/include/gtest/gtest.h"
17 const int kLineNumber
= 1776;
18 const char kFile
[] = "FixedUnitTestFileName";
19 const char kWorkerThreadName
[] = "WorkerThread-1";
20 const char kMainThreadName
[] = "SomeMainThreadName";
21 const char kStillAlive
[] = "Still_Alive";
23 namespace tracked_objects
{
25 class TrackedObjectsTest
: public testing::Test
{
27 TrackedObjectsTest() {
28 // On entry, leak any database structures in case they are still in use by
30 ThreadData::ShutdownSingleThreadedCleanup(true);
33 ThreadData::SetAlternateTimeSource(&TrackedObjectsTest::GetTestTime
);
34 ThreadData::now_function_is_time_
= true;
37 virtual ~TrackedObjectsTest() {
38 // We should not need to leak any structures we create, since we are
39 // single threaded, and carefully accounting for items.
40 ThreadData::ShutdownSingleThreadedCleanup(false);
43 // Reset the profiler state.
45 ThreadData::ShutdownSingleThreadedCleanup(false);
49 // Simulate a birth on the thread named |thread_name|, at the given
51 void TallyABirth(const Location
& location
, const std::string
& thread_name
) {
52 // If the |thread_name| is empty, we don't initialize system with a thread
53 // name, so we're viewed as a worker thread.
54 if (!thread_name
.empty())
55 ThreadData::InitializeThreadContext(kMainThreadName
);
57 // Do not delete |birth|. We don't own it.
58 Births
* birth
= ThreadData::TallyABirthIfActive(location
);
60 if (ThreadData::status() == ThreadData::DEACTIVATED
)
61 EXPECT_EQ(reinterpret_cast<Births
*>(NULL
), birth
);
63 EXPECT_NE(reinterpret_cast<Births
*>(NULL
), birth
);
66 // Helper function to verify the most common test expectations.
67 void ExpectSimpleProcessData(const ProcessDataSnapshot
& process_data
,
68 const std::string
& function_name
,
69 const std::string
& birth_thread
,
70 const std::string
& death_thread
,
74 ASSERT_EQ(1u, process_data
.tasks
.size());
76 EXPECT_EQ(kFile
, process_data
.tasks
[0].birth
.location
.file_name
);
77 EXPECT_EQ(function_name
,
78 process_data
.tasks
[0].birth
.location
.function_name
);
79 EXPECT_EQ(kLineNumber
, process_data
.tasks
[0].birth
.location
.line_number
);
81 EXPECT_EQ(birth_thread
, process_data
.tasks
[0].birth
.thread_name
);
83 EXPECT_EQ(count
, process_data
.tasks
[0].death_data
.count
);
84 EXPECT_EQ(count
* run_ms
,
85 process_data
.tasks
[0].death_data
.run_duration_sum
);
86 EXPECT_EQ(run_ms
, process_data
.tasks
[0].death_data
.run_duration_max
);
87 EXPECT_EQ(run_ms
, process_data
.tasks
[0].death_data
.run_duration_sample
);
88 EXPECT_EQ(count
* queue_ms
,
89 process_data
.tasks
[0].death_data
.queue_duration_sum
);
90 EXPECT_EQ(queue_ms
, process_data
.tasks
[0].death_data
.queue_duration_max
);
91 EXPECT_EQ(queue_ms
, process_data
.tasks
[0].death_data
.queue_duration_sample
);
93 EXPECT_EQ(death_thread
, process_data
.tasks
[0].death_thread_name
);
95 EXPECT_EQ(0u, process_data
.descendants
.size());
97 EXPECT_EQ(base::GetCurrentProcId(), process_data
.process_id
);
100 // Sets time that will be returned by ThreadData::Now().
101 static void SetTestTime(unsigned int test_time
) { test_time_
= test_time
; }
104 // Returns test time in milliseconds.
105 static unsigned int GetTestTime() { return test_time_
; }
107 // Test time in milliseconds.
108 static unsigned int test_time_
;
112 unsigned int TrackedObjectsTest::test_time_
;
115 TEST_F(TrackedObjectsTest
, MinimalStartupShutdown
) {
116 // Minimal test doesn't even create any tasks.
117 if (!ThreadData::InitializeAndSetTrackingStatus(
118 ThreadData::PROFILING_CHILDREN_ACTIVE
)) {
122 EXPECT_FALSE(ThreadData::first()); // No activity even on this thread.
123 ThreadData
* data
= ThreadData::Get();
124 EXPECT_TRUE(ThreadData::first()); // Now class was constructed.
126 EXPECT_FALSE(data
->next());
127 EXPECT_EQ(data
, ThreadData::Get());
128 ThreadData::BirthMap birth_map
;
129 ThreadData::DeathMap death_map
;
130 ThreadData::ParentChildSet parent_child_set
;
131 data
->SnapshotMaps(false, &birth_map
, &death_map
, &parent_child_set
);
132 EXPECT_EQ(0u, birth_map
.size());
133 EXPECT_EQ(0u, death_map
.size());
134 EXPECT_EQ(0u, parent_child_set
.size());
136 // Clean up with no leaking.
139 // Do it again, just to be sure we reset state completely.
140 EXPECT_TRUE(ThreadData::InitializeAndSetTrackingStatus(
141 ThreadData::PROFILING_CHILDREN_ACTIVE
));
142 EXPECT_FALSE(ThreadData::first()); // No activity even on this thread.
143 data
= ThreadData::Get();
144 EXPECT_TRUE(ThreadData::first()); // Now class was constructed.
146 EXPECT_FALSE(data
->next());
147 EXPECT_EQ(data
, ThreadData::Get());
150 parent_child_set
.clear();
151 data
->SnapshotMaps(false, &birth_map
, &death_map
, &parent_child_set
);
152 EXPECT_EQ(0u, birth_map
.size());
153 EXPECT_EQ(0u, death_map
.size());
154 EXPECT_EQ(0u, parent_child_set
.size());
157 TEST_F(TrackedObjectsTest
, TinyStartupShutdown
) {
158 if (!ThreadData::InitializeAndSetTrackingStatus(
159 ThreadData::PROFILING_CHILDREN_ACTIVE
)) {
163 // Instigate tracking on a single tracked object, on our thread.
164 const char kFunction
[] = "TinyStartupShutdown";
165 Location
location(kFunction
, kFile
, kLineNumber
, NULL
);
166 Births
* first_birth
= ThreadData::TallyABirthIfActive(location
);
168 ThreadData
* data
= ThreadData::first();
170 EXPECT_FALSE(data
->next());
171 EXPECT_EQ(data
, ThreadData::Get());
172 ThreadData::BirthMap birth_map
;
173 ThreadData::DeathMap death_map
;
174 ThreadData::ParentChildSet parent_child_set
;
175 data
->SnapshotMaps(false, &birth_map
, &death_map
, &parent_child_set
);
176 EXPECT_EQ(1u, birth_map
.size()); // 1 birth location.
177 EXPECT_EQ(1, birth_map
.begin()->second
->birth_count()); // 1 birth.
178 EXPECT_EQ(0u, death_map
.size()); // No deaths.
179 EXPECT_EQ(0u, parent_child_set
.size()); // No children.
182 // Now instigate another birth, while we are timing the run of the first
184 ThreadData::PrepareForStartOfRun(first_birth
);
185 // Create a child (using the same birth location).
186 // TrackingInfo will call TallyABirth() during construction.
187 const int32 start_time
= 1;
188 base::TimeTicks kBogusBirthTime
= base::TimeTicks() +
189 base::TimeDelta::FromMilliseconds(start_time
);
190 base::TrackingInfo
pending_task(location
, kBogusBirthTime
);
192 TaskStopwatch stopwatch
;
193 // Finally conclude the outer run.
194 const int32 time_elapsed
= 1000;
195 SetTestTime(start_time
+ time_elapsed
);
198 ThreadData::TallyRunOnNamedThreadIfTracking(pending_task
, stopwatch
);
202 parent_child_set
.clear();
203 data
->SnapshotMaps(false, &birth_map
, &death_map
, &parent_child_set
);
204 EXPECT_EQ(1u, birth_map
.size()); // 1 birth location.
205 EXPECT_EQ(2, birth_map
.begin()->second
->birth_count()); // 2 births.
206 EXPECT_EQ(1u, death_map
.size()); // 1 location.
207 EXPECT_EQ(1, death_map
.begin()->second
.count()); // 1 death.
208 if (ThreadData::TrackingParentChildStatus()) {
209 EXPECT_EQ(1u, parent_child_set
.size()); // 1 child.
210 EXPECT_EQ(parent_child_set
.begin()->first
,
211 parent_child_set
.begin()->second
);
213 EXPECT_EQ(0u, parent_child_set
.size()); // no stats.
216 // The births were at the same location as the one known death.
217 EXPECT_EQ(birth_map
.begin()->second
, death_map
.begin()->first
);
219 ProcessDataSnapshot process_data
;
220 ThreadData::Snapshot(false, &process_data
);
222 ASSERT_EQ(1u, process_data
.tasks
.size());
223 EXPECT_EQ(kFile
, process_data
.tasks
[0].birth
.location
.file_name
);
224 EXPECT_EQ(kFunction
, process_data
.tasks
[0].birth
.location
.function_name
);
225 EXPECT_EQ(kLineNumber
, process_data
.tasks
[0].birth
.location
.line_number
);
226 EXPECT_EQ(kWorkerThreadName
, process_data
.tasks
[0].birth
.thread_name
);
227 EXPECT_EQ(1, process_data
.tasks
[0].death_data
.count
);
228 EXPECT_EQ(time_elapsed
, process_data
.tasks
[0].death_data
.run_duration_sum
);
229 EXPECT_EQ(time_elapsed
, process_data
.tasks
[0].death_data
.run_duration_max
);
230 EXPECT_EQ(time_elapsed
, process_data
.tasks
[0].death_data
.run_duration_sample
);
231 EXPECT_EQ(0, process_data
.tasks
[0].death_data
.queue_duration_sum
);
232 EXPECT_EQ(0, process_data
.tasks
[0].death_data
.queue_duration_max
);
233 EXPECT_EQ(0, process_data
.tasks
[0].death_data
.queue_duration_sample
);
234 EXPECT_EQ(kWorkerThreadName
, process_data
.tasks
[0].death_thread_name
);
236 if (ThreadData::TrackingParentChildStatus()) {
237 ASSERT_EQ(1u, process_data
.descendants
.size());
238 EXPECT_EQ(kFile
, process_data
.descendants
[0].parent
.location
.file_name
);
240 process_data
.descendants
[0].parent
.location
.function_name
);
241 EXPECT_EQ(kLineNumber
,
242 process_data
.descendants
[0].parent
.location
.line_number
);
243 EXPECT_EQ(kWorkerThreadName
,
244 process_data
.descendants
[0].parent
.thread_name
);
245 EXPECT_EQ(kFile
, process_data
.descendants
[0].child
.location
.file_name
);
247 process_data
.descendants
[0].child
.location
.function_name
);
248 EXPECT_EQ(kLineNumber
,
249 process_data
.descendants
[0].child
.location
.line_number
);
250 EXPECT_EQ(kWorkerThreadName
, process_data
.descendants
[0].child
.thread_name
);
252 EXPECT_EQ(0u, process_data
.descendants
.size());
256 TEST_F(TrackedObjectsTest
, DeathDataTest
) {
257 if (!ThreadData::InitializeAndSetTrackingStatus(
258 ThreadData::PROFILING_CHILDREN_ACTIVE
)) {
262 scoped_ptr
<DeathData
> data(new DeathData());
263 ASSERT_NE(data
, reinterpret_cast<DeathData
*>(NULL
));
264 EXPECT_EQ(data
->run_duration_sum(), 0);
265 EXPECT_EQ(data
->run_duration_sample(), 0);
266 EXPECT_EQ(data
->queue_duration_sum(), 0);
267 EXPECT_EQ(data
->queue_duration_sample(), 0);
268 EXPECT_EQ(data
->count(), 0);
273 const int kUnrandomInt
= 0; // Fake random int that ensure we sample data.
274 data
->RecordDeath(queue_ms
, run_ms
, kUnrandomInt
);
275 EXPECT_EQ(data
->run_duration_sum(), run_ms
);
276 EXPECT_EQ(data
->run_duration_sample(), run_ms
);
277 EXPECT_EQ(data
->queue_duration_sum(), queue_ms
);
278 EXPECT_EQ(data
->queue_duration_sample(), queue_ms
);
279 EXPECT_EQ(data
->count(), 1);
281 data
->RecordDeath(queue_ms
, run_ms
, kUnrandomInt
);
282 EXPECT_EQ(data
->run_duration_sum(), run_ms
+ run_ms
);
283 EXPECT_EQ(data
->run_duration_sample(), run_ms
);
284 EXPECT_EQ(data
->queue_duration_sum(), queue_ms
+ queue_ms
);
285 EXPECT_EQ(data
->queue_duration_sample(), queue_ms
);
286 EXPECT_EQ(data
->count(), 2);
288 DeathDataSnapshot
snapshot(*data
);
289 EXPECT_EQ(2, snapshot
.count
);
290 EXPECT_EQ(2 * run_ms
, snapshot
.run_duration_sum
);
291 EXPECT_EQ(run_ms
, snapshot
.run_duration_max
);
292 EXPECT_EQ(run_ms
, snapshot
.run_duration_sample
);
293 EXPECT_EQ(2 * queue_ms
, snapshot
.queue_duration_sum
);
294 EXPECT_EQ(queue_ms
, snapshot
.queue_duration_max
);
295 EXPECT_EQ(queue_ms
, snapshot
.queue_duration_sample
);
298 TEST_F(TrackedObjectsTest
, DeactivatedBirthOnlyToSnapshotWorkerThread
) {
299 // Start in the deactivated state.
300 if (!ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED
)) {
304 const char kFunction
[] = "DeactivatedBirthOnlyToSnapshotWorkerThread";
305 Location
location(kFunction
, kFile
, kLineNumber
, NULL
);
306 TallyABirth(location
, std::string());
308 ProcessDataSnapshot process_data
;
309 ThreadData::Snapshot(false, &process_data
);
310 EXPECT_EQ(0u, process_data
.tasks
.size());
311 EXPECT_EQ(0u, process_data
.descendants
.size());
312 EXPECT_EQ(base::GetCurrentProcId(), process_data
.process_id
);
315 TEST_F(TrackedObjectsTest
, DeactivatedBirthOnlyToSnapshotMainThread
) {
316 // Start in the deactivated state.
317 if (!ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED
)) {
321 const char kFunction
[] = "DeactivatedBirthOnlyToSnapshotMainThread";
322 Location
location(kFunction
, kFile
, kLineNumber
, NULL
);
323 TallyABirth(location
, kMainThreadName
);
325 ProcessDataSnapshot process_data
;
326 ThreadData::Snapshot(false, &process_data
);
327 EXPECT_EQ(0u, process_data
.tasks
.size());
328 EXPECT_EQ(0u, process_data
.descendants
.size());
329 EXPECT_EQ(base::GetCurrentProcId(), process_data
.process_id
);
332 TEST_F(TrackedObjectsTest
, BirthOnlyToSnapshotWorkerThread
) {
333 if (!ThreadData::InitializeAndSetTrackingStatus(
334 ThreadData::PROFILING_CHILDREN_ACTIVE
)) {
338 const char kFunction
[] = "BirthOnlyToSnapshotWorkerThread";
339 Location
location(kFunction
, kFile
, kLineNumber
, NULL
);
340 TallyABirth(location
, std::string());
342 ProcessDataSnapshot process_data
;
343 ThreadData::Snapshot(false, &process_data
);
344 ExpectSimpleProcessData(process_data
, kFunction
, kWorkerThreadName
,
345 kStillAlive
, 1, 0, 0);
348 TEST_F(TrackedObjectsTest
, BirthOnlyToSnapshotMainThread
) {
349 if (!ThreadData::InitializeAndSetTrackingStatus(
350 ThreadData::PROFILING_CHILDREN_ACTIVE
)) {
354 const char kFunction
[] = "BirthOnlyToSnapshotMainThread";
355 Location
location(kFunction
, kFile
, kLineNumber
, NULL
);
356 TallyABirth(location
, kMainThreadName
);
358 ProcessDataSnapshot process_data
;
359 ThreadData::Snapshot(false, &process_data
);
360 ExpectSimpleProcessData(process_data
, kFunction
, kMainThreadName
, kStillAlive
,
364 TEST_F(TrackedObjectsTest
, LifeCycleToSnapshotMainThread
) {
365 if (!ThreadData::InitializeAndSetTrackingStatus(
366 ThreadData::PROFILING_CHILDREN_ACTIVE
)) {
370 const char kFunction
[] = "LifeCycleToSnapshotMainThread";
371 Location
location(kFunction
, kFile
, kLineNumber
, NULL
);
372 TallyABirth(location
, kMainThreadName
);
374 const base::TimeTicks kTimePosted
= base::TimeTicks() +
375 base::TimeDelta::FromMilliseconds(1);
376 const base::TimeTicks kDelayedStartTime
= base::TimeTicks();
377 // TrackingInfo will call TallyABirth() during construction.
378 base::TrackingInfo
pending_task(location
, kDelayedStartTime
);
379 pending_task
.time_posted
= kTimePosted
; // Overwrite implied Now().
381 const unsigned int kStartOfRun
= 5;
382 const unsigned int kEndOfRun
= 7;
383 SetTestTime(kStartOfRun
);
384 TaskStopwatch stopwatch
;
385 SetTestTime(kEndOfRun
);
388 ThreadData::TallyRunOnNamedThreadIfTracking(pending_task
, stopwatch
);
390 ProcessDataSnapshot process_data
;
391 ThreadData::Snapshot(false, &process_data
);
392 ExpectSimpleProcessData(process_data
, kFunction
, kMainThreadName
,
393 kMainThreadName
, 1, 2, 4);
396 // We will deactivate tracking after the birth, and before the death, and
397 // demonstrate that the lifecycle is completely tallied. This ensures that
398 // our tallied births are matched by tallied deaths (except for when the
399 // task is still running, or is queued).
400 TEST_F(TrackedObjectsTest
, LifeCycleMidDeactivatedToSnapshotMainThread
) {
401 if (!ThreadData::InitializeAndSetTrackingStatus(
402 ThreadData::PROFILING_CHILDREN_ACTIVE
)) {
406 const char kFunction
[] = "LifeCycleMidDeactivatedToSnapshotMainThread";
407 Location
location(kFunction
, kFile
, kLineNumber
, NULL
);
408 TallyABirth(location
, kMainThreadName
);
410 const base::TimeTicks kTimePosted
= base::TimeTicks() +
411 base::TimeDelta::FromMilliseconds(1);
412 const base::TimeTicks kDelayedStartTime
= base::TimeTicks();
413 // TrackingInfo will call TallyABirth() during construction.
414 base::TrackingInfo
pending_task(location
, kDelayedStartTime
);
415 pending_task
.time_posted
= kTimePosted
; // Overwrite implied Now().
417 // Turn off tracking now that we have births.
418 EXPECT_TRUE(ThreadData::InitializeAndSetTrackingStatus(
419 ThreadData::DEACTIVATED
));
421 const unsigned int kStartOfRun
= 5;
422 const unsigned int kEndOfRun
= 7;
423 SetTestTime(kStartOfRun
);
424 TaskStopwatch stopwatch
;
425 SetTestTime(kEndOfRun
);
428 ThreadData::TallyRunOnNamedThreadIfTracking(pending_task
, stopwatch
);
430 ProcessDataSnapshot process_data
;
431 ThreadData::Snapshot(false, &process_data
);
432 ExpectSimpleProcessData(process_data
, kFunction
, kMainThreadName
,
433 kMainThreadName
, 1, 2, 4);
436 // We will deactivate tracking before starting a life cycle, and neither
437 // the birth nor the death will be recorded.
438 TEST_F(TrackedObjectsTest
, LifeCyclePreDeactivatedToSnapshotMainThread
) {
439 // Start in the deactivated state.
440 if (!ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED
)) {
444 const char kFunction
[] = "LifeCyclePreDeactivatedToSnapshotMainThread";
445 Location
location(kFunction
, kFile
, kLineNumber
, NULL
);
446 TallyABirth(location
, kMainThreadName
);
448 const base::TimeTicks kTimePosted
= base::TimeTicks() +
449 base::TimeDelta::FromMilliseconds(1);
450 const base::TimeTicks kDelayedStartTime
= base::TimeTicks();
451 // TrackingInfo will call TallyABirth() during construction.
452 base::TrackingInfo
pending_task(location
, kDelayedStartTime
);
453 pending_task
.time_posted
= kTimePosted
; // Overwrite implied Now().
455 const unsigned int kStartOfRun
= 5;
456 const unsigned int kEndOfRun
= 7;
457 SetTestTime(kStartOfRun
);
458 TaskStopwatch stopwatch
;
459 SetTestTime(kEndOfRun
);
462 ThreadData::TallyRunOnNamedThreadIfTracking(pending_task
, stopwatch
);
464 ProcessDataSnapshot process_data
;
465 ThreadData::Snapshot(false, &process_data
);
466 EXPECT_EQ(0u, process_data
.tasks
.size());
467 EXPECT_EQ(0u, process_data
.descendants
.size());
468 EXPECT_EQ(base::GetCurrentProcId(), process_data
.process_id
);
471 TEST_F(TrackedObjectsTest
, LifeCycleToSnapshotWorkerThread
) {
472 if (!ThreadData::InitializeAndSetTrackingStatus(
473 ThreadData::PROFILING_CHILDREN_ACTIVE
)) {
477 const char kFunction
[] = "LifeCycleToSnapshotWorkerThread";
478 Location
location(kFunction
, kFile
, kLineNumber
, NULL
);
479 // Do not delete |birth|. We don't own it.
480 Births
* birth
= ThreadData::TallyABirthIfActive(location
);
481 EXPECT_NE(reinterpret_cast<Births
*>(NULL
), birth
);
483 const unsigned int kTimePosted
= 1;
484 const unsigned int kStartOfRun
= 5;
485 const unsigned int kEndOfRun
= 7;
486 SetTestTime(kStartOfRun
);
487 TaskStopwatch stopwatch
;
488 SetTestTime(kEndOfRun
);
491 ThreadData::TallyRunOnWorkerThreadIfTracking(
492 birth
, TrackedTime() + Duration::FromMilliseconds(kTimePosted
), stopwatch
);
494 // Call for the ToSnapshot, but tell it to not reset the maxes after scanning.
495 ProcessDataSnapshot process_data
;
496 ThreadData::Snapshot(false, &process_data
);
497 ExpectSimpleProcessData(process_data
, kFunction
, kWorkerThreadName
,
498 kWorkerThreadName
, 1, 2, 4);
500 // Call for the ToSnapshot, but tell it to reset the maxes after scanning.
501 // We'll still get the same values, but the data will be reset (which we'll
503 ProcessDataSnapshot process_data_pre_reset
;
504 ThreadData::Snapshot(true, &process_data_pre_reset
);
505 ExpectSimpleProcessData(process_data
, kFunction
, kWorkerThreadName
,
506 kWorkerThreadName
, 1, 2, 4);
508 // Call for the ToSnapshot, and now we'll see the result of the last
509 // translation, as the max will have been pushed back to zero.
510 ProcessDataSnapshot process_data_post_reset
;
511 ThreadData::Snapshot(true, &process_data_post_reset
);
512 ASSERT_EQ(1u, process_data_post_reset
.tasks
.size());
513 EXPECT_EQ(kFile
, process_data_post_reset
.tasks
[0].birth
.location
.file_name
);
515 process_data_post_reset
.tasks
[0].birth
.location
.function_name
);
516 EXPECT_EQ(kLineNumber
,
517 process_data_post_reset
.tasks
[0].birth
.location
.line_number
);
518 EXPECT_EQ(kWorkerThreadName
,
519 process_data_post_reset
.tasks
[0].birth
.thread_name
);
520 EXPECT_EQ(1, process_data_post_reset
.tasks
[0].death_data
.count
);
521 EXPECT_EQ(2, process_data_post_reset
.tasks
[0].death_data
.run_duration_sum
);
522 EXPECT_EQ(0, process_data_post_reset
.tasks
[0].death_data
.run_duration_max
);
523 EXPECT_EQ(2, process_data_post_reset
.tasks
[0].death_data
.run_duration_sample
);
524 EXPECT_EQ(4, process_data_post_reset
.tasks
[0].death_data
.queue_duration_sum
);
525 EXPECT_EQ(0, process_data_post_reset
.tasks
[0].death_data
.queue_duration_max
);
527 process_data_post_reset
.tasks
[0].death_data
.queue_duration_sample
);
528 EXPECT_EQ(kWorkerThreadName
,
529 process_data_post_reset
.tasks
[0].death_thread_name
);
530 EXPECT_EQ(0u, process_data_post_reset
.descendants
.size());
531 EXPECT_EQ(base::GetCurrentProcId(), process_data_post_reset
.process_id
);
534 TEST_F(TrackedObjectsTest
, TwoLives
) {
535 if (!ThreadData::InitializeAndSetTrackingStatus(
536 ThreadData::PROFILING_CHILDREN_ACTIVE
)) {
540 const char kFunction
[] = "TwoLives";
541 Location
location(kFunction
, kFile
, kLineNumber
, NULL
);
542 TallyABirth(location
, kMainThreadName
);
544 const base::TimeTicks kTimePosted
= base::TimeTicks() +
545 base::TimeDelta::FromMilliseconds(1);
546 const base::TimeTicks kDelayedStartTime
= base::TimeTicks();
547 // TrackingInfo will call TallyABirth() during construction.
548 base::TrackingInfo
pending_task(location
, kDelayedStartTime
);
549 pending_task
.time_posted
= kTimePosted
; // Overwrite implied Now().
551 const unsigned int kStartOfRun
= 5;
552 const unsigned int kEndOfRun
= 7;
553 SetTestTime(kStartOfRun
);
554 TaskStopwatch stopwatch
;
555 SetTestTime(kEndOfRun
);
558 ThreadData::TallyRunOnNamedThreadIfTracking(pending_task
, stopwatch
);
560 // TrackingInfo will call TallyABirth() during construction.
561 base::TrackingInfo
pending_task2(location
, kDelayedStartTime
);
562 pending_task2
.time_posted
= kTimePosted
; // Overwrite implied Now().
563 SetTestTime(kStartOfRun
);
564 TaskStopwatch stopwatch2
;
565 SetTestTime(kEndOfRun
);
568 ThreadData::TallyRunOnNamedThreadIfTracking(pending_task2
, stopwatch2
);
570 ProcessDataSnapshot process_data
;
571 ThreadData::Snapshot(false, &process_data
);
572 ExpectSimpleProcessData(process_data
, kFunction
, kMainThreadName
,
573 kMainThreadName
, 2, 2, 4);
576 TEST_F(TrackedObjectsTest
, DifferentLives
) {
577 if (!ThreadData::InitializeAndSetTrackingStatus(
578 ThreadData::PROFILING_CHILDREN_ACTIVE
)) {
582 // Use a well named thread.
583 ThreadData::InitializeThreadContext(kMainThreadName
);
584 const char kFunction
[] = "DifferentLives";
585 Location
location(kFunction
, kFile
, kLineNumber
, NULL
);
587 const base::TimeTicks kTimePosted
= base::TimeTicks() +
588 base::TimeDelta::FromMilliseconds(1);
589 const base::TimeTicks kDelayedStartTime
= base::TimeTicks();
590 // TrackingInfo will call TallyABirth() during construction.
591 base::TrackingInfo
pending_task(location
, kDelayedStartTime
);
592 pending_task
.time_posted
= kTimePosted
; // Overwrite implied Now().
594 const unsigned int kStartOfRun
= 5;
595 const unsigned int kEndOfRun
= 7;
596 SetTestTime(kStartOfRun
);
597 TaskStopwatch stopwatch
;
598 SetTestTime(kEndOfRun
);
601 ThreadData::TallyRunOnNamedThreadIfTracking(pending_task
, stopwatch
);
603 const int kSecondFakeLineNumber
= 999;
604 Location
second_location(kFunction
, kFile
, kSecondFakeLineNumber
, NULL
);
606 // TrackingInfo will call TallyABirth() during construction.
607 base::TrackingInfo
pending_task2(second_location
, kDelayedStartTime
);
608 pending_task2
.time_posted
= kTimePosted
; // Overwrite implied Now().
610 ProcessDataSnapshot process_data
;
611 ThreadData::Snapshot(false, &process_data
);
612 ASSERT_EQ(2u, process_data
.tasks
.size());
614 EXPECT_EQ(kFile
, process_data
.tasks
[0].birth
.location
.file_name
);
615 EXPECT_EQ(kFunction
, process_data
.tasks
[0].birth
.location
.function_name
);
616 EXPECT_EQ(kLineNumber
, process_data
.tasks
[0].birth
.location
.line_number
);
617 EXPECT_EQ(kMainThreadName
, process_data
.tasks
[0].birth
.thread_name
);
618 EXPECT_EQ(1, process_data
.tasks
[0].death_data
.count
);
619 EXPECT_EQ(2, process_data
.tasks
[0].death_data
.run_duration_sum
);
620 EXPECT_EQ(2, process_data
.tasks
[0].death_data
.run_duration_max
);
621 EXPECT_EQ(2, process_data
.tasks
[0].death_data
.run_duration_sample
);
622 EXPECT_EQ(4, process_data
.tasks
[0].death_data
.queue_duration_sum
);
623 EXPECT_EQ(4, process_data
.tasks
[0].death_data
.queue_duration_max
);
624 EXPECT_EQ(4, process_data
.tasks
[0].death_data
.queue_duration_sample
);
625 EXPECT_EQ(kMainThreadName
, process_data
.tasks
[0].death_thread_name
);
626 EXPECT_EQ(kFile
, process_data
.tasks
[1].birth
.location
.file_name
);
627 EXPECT_EQ(kFunction
, process_data
.tasks
[1].birth
.location
.function_name
);
628 EXPECT_EQ(kSecondFakeLineNumber
,
629 process_data
.tasks
[1].birth
.location
.line_number
);
630 EXPECT_EQ(kMainThreadName
, process_data
.tasks
[1].birth
.thread_name
);
631 EXPECT_EQ(1, process_data
.tasks
[1].death_data
.count
);
632 EXPECT_EQ(0, process_data
.tasks
[1].death_data
.run_duration_sum
);
633 EXPECT_EQ(0, process_data
.tasks
[1].death_data
.run_duration_max
);
634 EXPECT_EQ(0, process_data
.tasks
[1].death_data
.run_duration_sample
);
635 EXPECT_EQ(0, process_data
.tasks
[1].death_data
.queue_duration_sum
);
636 EXPECT_EQ(0, process_data
.tasks
[1].death_data
.queue_duration_max
);
637 EXPECT_EQ(0, process_data
.tasks
[1].death_data
.queue_duration_sample
);
638 EXPECT_EQ(kStillAlive
, process_data
.tasks
[1].death_thread_name
);
639 EXPECT_EQ(0u, process_data
.descendants
.size());
640 EXPECT_EQ(base::GetCurrentProcId(), process_data
.process_id
);
643 TEST_F(TrackedObjectsTest
, TaskWithNestedExclusion
) {
644 if (!ThreadData::InitializeAndSetTrackingStatus(
645 ThreadData::PROFILING_CHILDREN_ACTIVE
)) {
649 const char kFunction
[] = "TaskWithNestedExclusion";
650 Location
location(kFunction
, kFile
, kLineNumber
, NULL
);
651 TallyABirth(location
, kMainThreadName
);
653 const base::TimeTicks kTimePosted
= base::TimeTicks() +
654 base::TimeDelta::FromMilliseconds(1);
655 const base::TimeTicks kDelayedStartTime
= base::TimeTicks();
656 // TrackingInfo will call TallyABirth() during construction.
657 base::TrackingInfo
pending_task(location
, kDelayedStartTime
);
658 pending_task
.time_posted
= kTimePosted
; // Overwrite implied Now().
661 TaskStopwatch task_stopwatch
;
664 TaskStopwatch exclusion_stopwatch
;
666 exclusion_stopwatch
.Stop();
669 task_stopwatch
.Stop();
671 ThreadData::TallyRunOnNamedThreadIfTracking(pending_task
, task_stopwatch
);
673 ProcessDataSnapshot process_data
;
674 ThreadData::Snapshot(false, &process_data
);
675 ExpectSimpleProcessData(process_data
, kFunction
, kMainThreadName
,
676 kMainThreadName
, 1, 6, 4);
679 TEST_F(TrackedObjectsTest
, TaskWith2NestedExclusions
) {
680 if (!ThreadData::InitializeAndSetTrackingStatus(
681 ThreadData::PROFILING_CHILDREN_ACTIVE
)) {
685 const char kFunction
[] = "TaskWith2NestedExclusions";
686 Location
location(kFunction
, kFile
, kLineNumber
, NULL
);
687 TallyABirth(location
, kMainThreadName
);
689 const base::TimeTicks kTimePosted
= base::TimeTicks() +
690 base::TimeDelta::FromMilliseconds(1);
691 const base::TimeTicks kDelayedStartTime
= base::TimeTicks();
692 // TrackingInfo will call TallyABirth() during construction.
693 base::TrackingInfo
pending_task(location
, kDelayedStartTime
);
694 pending_task
.time_posted
= kTimePosted
; // Overwrite implied Now().
697 TaskStopwatch task_stopwatch
;
700 TaskStopwatch exclusion_stopwatch
;
702 exclusion_stopwatch
.Stop();
705 TaskStopwatch exclusion_stopwatch2
;
707 exclusion_stopwatch2
.Stop();
710 task_stopwatch
.Stop();
712 ThreadData::TallyRunOnNamedThreadIfTracking(pending_task
, task_stopwatch
);
714 ProcessDataSnapshot process_data
;
715 ThreadData::Snapshot(false, &process_data
);
716 ExpectSimpleProcessData(process_data
, kFunction
, kMainThreadName
,
717 kMainThreadName
, 1, 13, 4);
720 TEST_F(TrackedObjectsTest
, TaskWithNestedExclusionWithNestedTask
) {
721 if (!ThreadData::InitializeAndSetTrackingStatus(
722 ThreadData::PROFILING_CHILDREN_ACTIVE
)) {
726 const char kFunction
[] = "TaskWithNestedExclusionWithNestedTask";
727 Location
location(kFunction
, kFile
, kLineNumber
, NULL
);
729 const int kSecondFakeLineNumber
= 999;
731 TallyABirth(location
, kMainThreadName
);
733 const base::TimeTicks kTimePosted
= base::TimeTicks() +
734 base::TimeDelta::FromMilliseconds(1);
735 const base::TimeTicks kDelayedStartTime
= base::TimeTicks();
736 // TrackingInfo will call TallyABirth() during construction.
737 base::TrackingInfo
pending_task(location
, kDelayedStartTime
);
738 pending_task
.time_posted
= kTimePosted
; // Overwrite implied Now().
741 TaskStopwatch task_stopwatch
;
744 TaskStopwatch exclusion_stopwatch
;
746 Location
second_location(kFunction
, kFile
, kSecondFakeLineNumber
, NULL
);
747 base::TrackingInfo
nested_task(second_location
, kDelayedStartTime
);
748 // Overwrite implied Now().
749 nested_task
.time_posted
=
750 base::TimeTicks() + base::TimeDelta::FromMilliseconds(8);
752 TaskStopwatch nested_task_stopwatch
;
754 nested_task_stopwatch
.Stop();
755 ThreadData::TallyRunOnNamedThreadIfTracking(
756 nested_task
, nested_task_stopwatch
);
759 exclusion_stopwatch
.Stop();
762 task_stopwatch
.Stop();
764 ThreadData::TallyRunOnNamedThreadIfTracking(pending_task
, task_stopwatch
);
766 ProcessDataSnapshot process_data
;
767 ThreadData::Snapshot(false, &process_data
);
769 // The order in which the two task follow is platform-dependent.
770 int t0
= (process_data
.tasks
[0].birth
.location
.line_number
== kLineNumber
) ?
774 ASSERT_EQ(2u, process_data
.tasks
.size());
775 EXPECT_EQ(kFile
, process_data
.tasks
[t0
].birth
.location
.file_name
);
776 EXPECT_EQ(kFunction
, process_data
.tasks
[t0
].birth
.location
.function_name
);
777 EXPECT_EQ(kLineNumber
, process_data
.tasks
[t0
].birth
.location
.line_number
);
778 EXPECT_EQ(kMainThreadName
, process_data
.tasks
[t0
].birth
.thread_name
);
779 EXPECT_EQ(1, process_data
.tasks
[t0
].death_data
.count
);
780 EXPECT_EQ(6, process_data
.tasks
[t0
].death_data
.run_duration_sum
);
781 EXPECT_EQ(6, process_data
.tasks
[t0
].death_data
.run_duration_max
);
782 EXPECT_EQ(6, process_data
.tasks
[t0
].death_data
.run_duration_sample
);
783 EXPECT_EQ(4, process_data
.tasks
[t0
].death_data
.queue_duration_sum
);
784 EXPECT_EQ(4, process_data
.tasks
[t0
].death_data
.queue_duration_max
);
785 EXPECT_EQ(4, process_data
.tasks
[t0
].death_data
.queue_duration_sample
);
786 EXPECT_EQ(kMainThreadName
, process_data
.tasks
[t0
].death_thread_name
);
787 EXPECT_EQ(kFile
, process_data
.tasks
[t1
].birth
.location
.file_name
);
788 EXPECT_EQ(kFunction
, process_data
.tasks
[t1
].birth
.location
.function_name
);
789 EXPECT_EQ(kSecondFakeLineNumber
,
790 process_data
.tasks
[t1
].birth
.location
.line_number
);
791 EXPECT_EQ(kMainThreadName
, process_data
.tasks
[t1
].birth
.thread_name
);
792 EXPECT_EQ(1, process_data
.tasks
[t1
].death_data
.count
);
793 EXPECT_EQ(2, process_data
.tasks
[t1
].death_data
.run_duration_sum
);
794 EXPECT_EQ(2, process_data
.tasks
[t1
].death_data
.run_duration_max
);
795 EXPECT_EQ(2, process_data
.tasks
[t1
].death_data
.run_duration_sample
);
796 EXPECT_EQ(1, process_data
.tasks
[t1
].death_data
.queue_duration_sum
);
797 EXPECT_EQ(1, process_data
.tasks
[t1
].death_data
.queue_duration_max
);
798 EXPECT_EQ(1, process_data
.tasks
[t1
].death_data
.queue_duration_sample
);
799 EXPECT_EQ(kMainThreadName
, process_data
.tasks
[t1
].death_thread_name
);
800 EXPECT_EQ(0u, process_data
.descendants
.size());
801 EXPECT_EQ(base::GetCurrentProcId(), process_data
.process_id
);
804 } // namespace tracked_objects