OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 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 #include "components/scheduler/base/task_queue_manager.h" | 5 #include "components/scheduler/base/task_queue_manager.h" |
6 | 6 |
7 #include "base/location.h" | 7 #include "base/location.h" |
8 #include "base/run_loop.h" | 8 #include "base/run_loop.h" |
9 #include "base/single_thread_task_runner.h" | 9 #include "base/single_thread_task_runner.h" |
10 #include "base/test/simple_test_tick_clock.h" | 10 #include "base/test/simple_test_tick_clock.h" |
(...skipping 1575 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1586 base::Callback<bool()> should_exit_; | 1586 base::Callback<bool()> should_exit_; |
1587 base::SimpleTestTickClock* now_src_; | 1587 base::SimpleTestTickClock* now_src_; |
1588 }; | 1588 }; |
1589 | 1589 |
1590 bool ShouldExit(QuadraticTask* quadratic_task, LinearTask* linear_task) { | 1590 bool ShouldExit(QuadraticTask* quadratic_task, LinearTask* linear_task) { |
1591 return quadratic_task->count() == 1000 || linear_task->count() == 1000; | 1591 return quadratic_task->count() == 1000 || linear_task->count() == 1000; |
1592 } | 1592 } |
1593 | 1593 |
1594 } // namespace | 1594 } // namespace |
1595 | 1595 |
1596 TEST_F(TaskQueueManagerTest, DelayedTasksDontStarveNonDelayedWork_SameQueue) { | 1596 TEST_F(TaskQueueManagerTest, |
| 1597 DelayedTasksDontBadlyStarveNonDelayedWork_SameQueue) { |
1597 Initialize(1u); | 1598 Initialize(1u); |
1598 | 1599 |
1599 QuadraticTask quadratic_delayed_task( | 1600 QuadraticTask quadratic_delayed_task( |
1600 runners_[0], base::TimeDelta::FromMilliseconds(10), now_src_.get()); | 1601 runners_[0], base::TimeDelta::FromMilliseconds(10), now_src_.get()); |
1601 LinearTask linear_immediate_task(runners_[0], base::TimeDelta(), | 1602 LinearTask linear_immediate_task(runners_[0], base::TimeDelta(), |
1602 now_src_.get()); | 1603 now_src_.get()); |
1603 base::Callback<bool()> should_exit = | 1604 base::Callback<bool()> should_exit = |
1604 base::Bind(ShouldExit, &quadratic_delayed_task, &linear_immediate_task); | 1605 base::Bind(ShouldExit, &quadratic_delayed_task, &linear_immediate_task); |
1605 quadratic_delayed_task.SetShouldExit(should_exit); | 1606 quadratic_delayed_task.SetShouldExit(should_exit); |
1606 linear_immediate_task.SetShouldExit(should_exit); | 1607 linear_immediate_task.SetShouldExit(should_exit); |
1607 | 1608 |
1608 quadratic_delayed_task.Run(); | 1609 quadratic_delayed_task.Run(); |
1609 linear_immediate_task.Run(); | 1610 linear_immediate_task.Run(); |
1610 | 1611 |
1611 test_task_runner_->SetAutoAdvanceNowToPendingTasks(true); | 1612 test_task_runner_->SetAutoAdvanceNowToPendingTasks(true); |
1612 test_task_runner_->RunUntilIdle(); | 1613 test_task_runner_->RunUntilIdle(); |
1613 | 1614 |
1614 double ratio = static_cast<double>(linear_immediate_task.count()) / | 1615 double ratio = static_cast<double>(linear_immediate_task.count()) / |
1615 static_cast<double>(quadratic_delayed_task.count()); | 1616 static_cast<double>(quadratic_delayed_task.count()); |
1616 | 1617 |
1617 EXPECT_GT(ratio, 0.9); | 1618 EXPECT_GT(ratio, 0.333); |
1618 EXPECT_LT(ratio, 1.1); | 1619 EXPECT_LT(ratio, 1.1); |
1619 } | 1620 } |
1620 | 1621 |
1621 TEST_F(TaskQueueManagerTest, ImmediateWorkCanStarveDelayedTasks_SameQueue) { | 1622 TEST_F(TaskQueueManagerTest, ImmediateWorkCanStarveDelayedTasks_SameQueue) { |
1622 Initialize(1u); | 1623 Initialize(1u); |
1623 | 1624 |
1624 QuadraticTask quadratic_immediate_task(runners_[0], base::TimeDelta(), | 1625 QuadraticTask quadratic_immediate_task(runners_[0], base::TimeDelta(), |
1625 now_src_.get()); | 1626 now_src_.get()); |
1626 LinearTask linear_delayed_task( | 1627 LinearTask linear_delayed_task( |
1627 runners_[0], base::TimeDelta::FromMilliseconds(10), now_src_.get()); | 1628 runners_[0], base::TimeDelta::FromMilliseconds(10), now_src_.get()); |
(...skipping 12 matching lines...) Expand all Loading... |
1640 double ratio = static_cast<double>(linear_delayed_task.count()) / | 1641 double ratio = static_cast<double>(linear_delayed_task.count()) / |
1641 static_cast<double>(quadratic_immediate_task.count()); | 1642 static_cast<double>(quadratic_immediate_task.count()); |
1642 | 1643 |
1643 // This is by design, we want to enforce a strict ordering in task execution | 1644 // This is by design, we want to enforce a strict ordering in task execution |
1644 // where by delayed tasks can not skip ahead of non-delayed work. | 1645 // where by delayed tasks can not skip ahead of non-delayed work. |
1645 EXPECT_GT(ratio, 0.0); | 1646 EXPECT_GT(ratio, 0.0); |
1646 EXPECT_LT(ratio, 0.1); | 1647 EXPECT_LT(ratio, 0.1); |
1647 } | 1648 } |
1648 | 1649 |
1649 TEST_F(TaskQueueManagerTest, | 1650 TEST_F(TaskQueueManagerTest, |
1650 DelayedTasksDontStarveNonDelayedWork_DifferentQueue) { | 1651 DelayedTasksDontBadlyStarveNonDelayedWork_DifferentQueue) { |
1651 Initialize(2u); | 1652 Initialize(2u); |
1652 | 1653 |
1653 QuadraticTask quadratic_delayed_task( | 1654 QuadraticTask quadratic_delayed_task( |
1654 runners_[0], base::TimeDelta::FromMilliseconds(10), now_src_.get()); | 1655 runners_[0], base::TimeDelta::FromMilliseconds(10), now_src_.get()); |
1655 LinearTask linear_immediate_task(runners_[1], base::TimeDelta(), | 1656 LinearTask linear_immediate_task(runners_[1], base::TimeDelta(), |
1656 now_src_.get()); | 1657 now_src_.get()); |
1657 base::Callback<bool()> should_exit = | 1658 base::Callback<bool()> should_exit = |
1658 base::Bind(ShouldExit, &quadratic_delayed_task, &linear_immediate_task); | 1659 base::Bind(ShouldExit, &quadratic_delayed_task, &linear_immediate_task); |
1659 quadratic_delayed_task.SetShouldExit(should_exit); | 1660 quadratic_delayed_task.SetShouldExit(should_exit); |
1660 linear_immediate_task.SetShouldExit(should_exit); | 1661 linear_immediate_task.SetShouldExit(should_exit); |
1661 | 1662 |
1662 quadratic_delayed_task.Run(); | 1663 quadratic_delayed_task.Run(); |
1663 linear_immediate_task.Run(); | 1664 linear_immediate_task.Run(); |
1664 | 1665 |
1665 test_task_runner_->SetAutoAdvanceNowToPendingTasks(true); | 1666 test_task_runner_->SetAutoAdvanceNowToPendingTasks(true); |
1666 test_task_runner_->RunUntilIdle(); | 1667 test_task_runner_->RunUntilIdle(); |
1667 | 1668 |
1668 double ratio = static_cast<double>(linear_immediate_task.count()) / | 1669 double ratio = static_cast<double>(linear_immediate_task.count()) / |
1669 static_cast<double>(quadratic_delayed_task.count()); | 1670 static_cast<double>(quadratic_delayed_task.count()); |
1670 | 1671 |
1671 EXPECT_GT(ratio, 0.9); | 1672 EXPECT_GT(ratio, 0.333); |
1672 EXPECT_LT(ratio, 1.1); | 1673 EXPECT_LT(ratio, 1.1); |
1673 } | 1674 } |
1674 | 1675 |
1675 TEST_F(TaskQueueManagerTest, | 1676 TEST_F(TaskQueueManagerTest, |
1676 ImmediateWorkCanStarveDelayedTasks_DifferentQueue) { | 1677 ImmediateWorkCanStarveDelayedTasks_DifferentQueue) { |
1677 Initialize(2u); | 1678 Initialize(2u); |
1678 | 1679 |
1679 QuadraticTask quadratic_immediate_task(runners_[0], base::TimeDelta(), | 1680 QuadraticTask quadratic_immediate_task(runners_[0], base::TimeDelta(), |
1680 now_src_.get()); | 1681 now_src_.get()); |
1681 LinearTask linear_delayed_task( | 1682 LinearTask linear_delayed_task( |
(...skipping 13 matching lines...) Expand all Loading... |
1695 double ratio = static_cast<double>(linear_delayed_task.count()) / | 1696 double ratio = static_cast<double>(linear_delayed_task.count()) / |
1696 static_cast<double>(quadratic_immediate_task.count()); | 1697 static_cast<double>(quadratic_immediate_task.count()); |
1697 | 1698 |
1698 // This is by design, we want to enforce a strict ordering in task execution | 1699 // This is by design, we want to enforce a strict ordering in task execution |
1699 // where by delayed tasks can not skip ahead of non-delayed work. | 1700 // where by delayed tasks can not skip ahead of non-delayed work. |
1700 EXPECT_GT(ratio, 0.0); | 1701 EXPECT_GT(ratio, 0.0); |
1701 EXPECT_LT(ratio, 0.1); | 1702 EXPECT_LT(ratio, 0.1); |
1702 } | 1703 } |
1703 | 1704 |
1704 } // namespace scheduler | 1705 } // namespace scheduler |
OLD | NEW |