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/task_scheduler_impl.h" | 5 #include "base/task_scheduler/task_scheduler_impl.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include <string> | 9 #include <string> |
10 #include <utility> | 10 #include <utility> |
(...skipping 153 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
164 params.push_back(TraitsExecutionModePair( | 164 params.push_back(TraitsExecutionModePair( |
165 TaskTraits().WithPriority(priority), execution_mode)); | 165 TaskTraits().WithPriority(priority), execution_mode)); |
166 params.push_back(TraitsExecutionModePair( | 166 params.push_back(TraitsExecutionModePair( |
167 TaskTraits().WithPriority(priority).MayBlock(), execution_mode)); | 167 TaskTraits().WithPriority(priority).MayBlock(), execution_mode)); |
168 } | 168 } |
169 } | 169 } |
170 | 170 |
171 return params; | 171 return params; |
172 } | 172 } |
173 | 173 |
174 enum WorkerPoolType { | |
175 BACKGROUND_WORKER_POOL = 0, | |
176 BACKGROUND_BLOCKING_WORKER_POOL, | |
177 FOREGROUND_WORKER_POOL, | |
178 FOREGROUND_BLOCKING_WORKER_POOL, | |
179 }; | |
180 | |
181 size_t GetThreadPoolIndexForTraits(const TaskTraits& traits) { | |
182 if (traits.may_block()) { | |
183 return traits.priority() == TaskPriority::BACKGROUND | |
184 ? BACKGROUND_BLOCKING_WORKER_POOL | |
185 : FOREGROUND_BLOCKING_WORKER_POOL; | |
186 } | |
187 return traits.priority() == TaskPriority::BACKGROUND ? BACKGROUND_WORKER_POOL | |
188 : FOREGROUND_WORKER_POOL; | |
189 } | |
190 | |
191 class TaskSchedulerImplTest | 174 class TaskSchedulerImplTest |
192 : public testing::TestWithParam<TraitsExecutionModePair> { | 175 : public testing::TestWithParam<TraitsExecutionModePair> { |
193 protected: | 176 protected: |
194 TaskSchedulerImplTest() = default; | 177 TaskSchedulerImplTest() = default; |
195 | 178 |
196 void SetUp() override { | 179 void SetUp() override { |
197 using StandbyThreadPolicy = SchedulerWorkerPoolParams::StandbyThreadPolicy; | 180 using StandbyThreadPolicy = SchedulerWorkerPoolParams::StandbyThreadPolicy; |
198 | 181 |
199 std::vector<SchedulerWorkerPoolParams> params_vector; | 182 constexpr TimeDelta kSuggestedReclaimTime = TimeDelta::FromSeconds(30); |
| 183 constexpr int kMaxNumBackgroundThreads = 1; |
| 184 constexpr int kMaxNumBackgroundBlockingThreads = 3; |
| 185 constexpr int kMaxNumForegroundThreads = 4; |
| 186 constexpr int kMaxNumForegroundBlockingThreads = 12; |
200 | 187 |
201 ASSERT_EQ(BACKGROUND_WORKER_POOL, params_vector.size()); | 188 scheduler_ = TaskSchedulerImpl::Create( |
202 params_vector.emplace_back("Background", ThreadPriority::BACKGROUND, | 189 "Test", {{StandbyThreadPolicy::LAZY, kMaxNumBackgroundThreads, |
203 StandbyThreadPolicy::LAZY, 1U, TimeDelta::Max()); | 190 kSuggestedReclaimTime}, |
204 | 191 {StandbyThreadPolicy::LAZY, kMaxNumBackgroundBlockingThreads, |
205 ASSERT_EQ(BACKGROUND_BLOCKING_WORKER_POOL, params_vector.size()); | 192 kSuggestedReclaimTime}, |
206 params_vector.emplace_back("BackgroundBlocking", ThreadPriority::BACKGROUND, | 193 {StandbyThreadPolicy::LAZY, kMaxNumForegroundThreads, |
207 StandbyThreadPolicy::LAZY, 3U, TimeDelta::Max()); | 194 kSuggestedReclaimTime}, |
208 | 195 {StandbyThreadPolicy::LAZY, kMaxNumForegroundBlockingThreads, |
209 ASSERT_EQ(FOREGROUND_WORKER_POOL, params_vector.size()); | 196 kSuggestedReclaimTime}}); |
210 params_vector.emplace_back("Foreground", ThreadPriority::NORMAL, | |
211 StandbyThreadPolicy::LAZY, 4U, TimeDelta::Max()); | |
212 | |
213 ASSERT_EQ(FOREGROUND_BLOCKING_WORKER_POOL, params_vector.size()); | |
214 params_vector.emplace_back("ForegroundBlocking", ThreadPriority::NORMAL, | |
215 StandbyThreadPolicy::LAZY, 12U, | |
216 TimeDelta::Max()); | |
217 | |
218 scheduler_ = TaskSchedulerImpl::Create(params_vector, | |
219 Bind(&GetThreadPoolIndexForTraits)); | |
220 ASSERT_TRUE(scheduler_); | 197 ASSERT_TRUE(scheduler_); |
221 } | 198 } |
222 | 199 |
223 void TearDown() override { scheduler_->JoinForTesting(); } | 200 void TearDown() override { scheduler_->JoinForTesting(); } |
224 | 201 |
225 std::unique_ptr<TaskSchedulerImpl> scheduler_; | 202 std::unique_ptr<TaskSchedulerImpl> scheduler_; |
226 | 203 |
227 private: | 204 private: |
228 DISALLOW_COPY_AND_ASSIGN(TaskSchedulerImplTest); | 205 DISALLOW_COPY_AND_ASSIGN(TaskSchedulerImplTest); |
229 }; | 206 }; |
(...skipping 131 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
361 WaitableEvent* task_ran) { | 338 WaitableEvent* task_ran) { |
362 EXPECT_FALSE(single_thread_task_runner->RunsTasksOnCurrentThread()); | 339 EXPECT_FALSE(single_thread_task_runner->RunsTasksOnCurrentThread()); |
363 task_ran->Signal(); | 340 task_ran->Signal(); |
364 }, | 341 }, |
365 single_thread_task_runner, Unretained(&task_ran))); | 342 single_thread_task_runner, Unretained(&task_ran))); |
366 task_ran.Wait(); | 343 task_ran.Wait(); |
367 } | 344 } |
368 | 345 |
369 } // namespace internal | 346 } // namespace internal |
370 } // namespace base | 347 } // namespace base |
OLD | NEW |