OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 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 "base/task_scheduler/scheduler_worker_pool_impl.h" | 5 #include "base/task_scheduler/scheduler_worker_pool_impl.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include <memory> | 9 #include <memory> |
10 #include <unordered_set> | 10 #include <unordered_set> |
(...skipping 66 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
77 } | 77 } |
78 | 78 |
79 void InitializeWorkerPool(TimeDelta suggested_reclaim_time, | 79 void InitializeWorkerPool(TimeDelta suggested_reclaim_time, |
80 size_t num_workers) { | 80 size_t num_workers) { |
81 ASSERT_FALSE(worker_pool_); | 81 ASSERT_FALSE(worker_pool_); |
82 ASSERT_FALSE(delayed_task_manager_); | 82 ASSERT_FALSE(delayed_task_manager_); |
83 service_thread_.Start(); | 83 service_thread_.Start(); |
84 delayed_task_manager_ = | 84 delayed_task_manager_ = |
85 base::MakeUnique<DelayedTaskManager>(service_thread_.task_runner()); | 85 base::MakeUnique<DelayedTaskManager>(service_thread_.task_runner()); |
86 worker_pool_ = SchedulerWorkerPoolImpl::Create( | 86 worker_pool_ = SchedulerWorkerPoolImpl::Create( |
87 SchedulerWorkerPoolParams("TestWorkerPool", ThreadPriority::NORMAL, | 87 "Test", ThreadPriority::NORMAL, |
88 StandbyThreadPolicy::LAZY, num_workers, | 88 {StandbyThreadPolicy::LAZY, num_workers, suggested_reclaim_time}, |
89 suggested_reclaim_time), | |
90 Bind(&TaskSchedulerWorkerPoolImplTest::ReEnqueueSequenceCallback, | 89 Bind(&TaskSchedulerWorkerPoolImplTest::ReEnqueueSequenceCallback, |
91 Unretained(this)), | 90 Unretained(this)), |
92 &task_tracker_, delayed_task_manager_.get()); | 91 &task_tracker_, delayed_task_manager_.get()); |
93 ASSERT_TRUE(worker_pool_); | 92 ASSERT_TRUE(worker_pool_); |
94 } | 93 } |
95 | 94 |
96 std::unique_ptr<SchedulerWorkerPoolImpl> worker_pool_; | 95 std::unique_ptr<SchedulerWorkerPoolImpl> worker_pool_; |
97 | 96 |
98 TaskTracker task_tracker_; | 97 TaskTracker task_tracker_; |
99 Thread service_thread_; | 98 Thread service_thread_; |
(...skipping 608 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
708 << "Unexpected invocation of NotReachedReEnqueueSequenceCallback."; | 707 << "Unexpected invocation of NotReachedReEnqueueSequenceCallback."; |
709 } | 708 } |
710 | 709 |
711 } // namespace | 710 } // namespace |
712 | 711 |
713 TEST(TaskSchedulerWorkerPoolStandbyPolicyTest, InitLazy) { | 712 TEST(TaskSchedulerWorkerPoolStandbyPolicyTest, InitLazy) { |
714 TaskTracker task_tracker; | 713 TaskTracker task_tracker; |
715 DelayedTaskManager delayed_task_manager( | 714 DelayedTaskManager delayed_task_manager( |
716 make_scoped_refptr(new TestSimpleTaskRunner)); | 715 make_scoped_refptr(new TestSimpleTaskRunner)); |
717 auto worker_pool = SchedulerWorkerPoolImpl::Create( | 716 auto worker_pool = SchedulerWorkerPoolImpl::Create( |
718 SchedulerWorkerPoolParams("LazyPolicyWorkerPool", ThreadPriority::NORMAL, | 717 "LazyPolicyWorkerPool", ThreadPriority::NORMAL, |
719 StandbyThreadPolicy::LAZY, 8U, | 718 {StandbyThreadPolicy::LAZY, 8U, TimeDelta::Max()}, |
720 TimeDelta::Max()), | |
721 Bind(&NotReachedReEnqueueSequenceCallback), &task_tracker, | 719 Bind(&NotReachedReEnqueueSequenceCallback), &task_tracker, |
722 &delayed_task_manager); | 720 &delayed_task_manager); |
723 ASSERT_TRUE(worker_pool); | 721 ASSERT_TRUE(worker_pool); |
724 EXPECT_EQ(0U, worker_pool->NumberOfAliveWorkersForTesting()); | 722 EXPECT_EQ(0U, worker_pool->NumberOfAliveWorkersForTesting()); |
725 worker_pool->JoinForTesting(); | 723 worker_pool->JoinForTesting(); |
726 } | 724 } |
727 | 725 |
728 TEST(TaskSchedulerWorkerPoolStandbyPolicyTest, InitOne) { | 726 TEST(TaskSchedulerWorkerPoolStandbyPolicyTest, InitOne) { |
729 TaskTracker task_tracker; | 727 TaskTracker task_tracker; |
730 DelayedTaskManager delayed_task_manager( | 728 DelayedTaskManager delayed_task_manager( |
731 make_scoped_refptr(new TestSimpleTaskRunner)); | 729 make_scoped_refptr(new TestSimpleTaskRunner)); |
732 auto worker_pool = SchedulerWorkerPoolImpl::Create( | 730 auto worker_pool = SchedulerWorkerPoolImpl::Create( |
733 SchedulerWorkerPoolParams("LazyPolicyWorkerPool", ThreadPriority::NORMAL, | 731 "LazyPolicyWorkerPool", ThreadPriority::NORMAL, |
734 StandbyThreadPolicy::ONE, 8U, TimeDelta::Max()), | 732 {StandbyThreadPolicy::ONE, 8U, TimeDelta::Max()}, |
735 Bind(&NotReachedReEnqueueSequenceCallback), &task_tracker, | 733 Bind(&NotReachedReEnqueueSequenceCallback), &task_tracker, |
736 &delayed_task_manager); | 734 &delayed_task_manager); |
737 ASSERT_TRUE(worker_pool); | 735 ASSERT_TRUE(worker_pool); |
738 EXPECT_EQ(1U, worker_pool->NumberOfAliveWorkersForTesting()); | 736 EXPECT_EQ(1U, worker_pool->NumberOfAliveWorkersForTesting()); |
739 worker_pool->JoinForTesting(); | 737 worker_pool->JoinForTesting(); |
740 } | 738 } |
741 | 739 |
742 } // namespace internal | 740 } // namespace internal |
743 } // namespace base | 741 } // namespace base |
OLD | NEW |