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 16 matching lines...) Expand all Loading... |
27 #include "base/time/time.h" | 27 #include "base/time/time.h" |
28 #include "testing/gtest/include/gtest/gtest.h" | 28 #include "testing/gtest/include/gtest/gtest.h" |
29 | 29 |
30 namespace base { | 30 namespace base { |
31 namespace internal { | 31 namespace internal { |
32 | 32 |
33 namespace { | 33 namespace { |
34 | 34 |
35 struct TraitsExecutionModePair { | 35 struct TraitsExecutionModePair { |
36 TraitsExecutionModePair(const TaskTraits& traits, | 36 TraitsExecutionModePair(const TaskTraits& traits, |
37 ExecutionMode execution_mode) | 37 test::ExecutionMode execution_mode) |
38 : traits(traits), execution_mode(execution_mode) {} | 38 : traits(traits), execution_mode(execution_mode) {} |
39 | 39 |
40 TaskTraits traits; | 40 TaskTraits traits; |
41 ExecutionMode execution_mode; | 41 test::ExecutionMode execution_mode; |
42 }; | 42 }; |
43 | 43 |
44 #if DCHECK_IS_ON() | 44 #if DCHECK_IS_ON() |
45 // Returns whether I/O calls are allowed on the current thread. | 45 // Returns whether I/O calls are allowed on the current thread. |
46 bool GetIOAllowed() { | 46 bool GetIOAllowed() { |
47 const bool previous_value = ThreadRestrictions::SetIOAllowed(true); | 47 const bool previous_value = ThreadRestrictions::SetIOAllowed(true); |
48 ThreadRestrictions::SetIOAllowed(previous_value); | 48 ThreadRestrictions::SetIOAllowed(previous_value); |
49 return previous_value; | 49 return previous_value; |
50 } | 50 } |
51 #endif | 51 #endif |
(...skipping 29 matching lines...) Expand all Loading... |
81 current_thread_name.find("FileIO") != std::string::npos); | 81 current_thread_name.find("FileIO") != std::string::npos); |
82 } | 82 } |
83 | 83 |
84 void VerifyTaskEnvironementAndSignalEvent(const TaskTraits& traits, | 84 void VerifyTaskEnvironementAndSignalEvent(const TaskTraits& traits, |
85 WaitableEvent* event) { | 85 WaitableEvent* event) { |
86 DCHECK(event); | 86 DCHECK(event); |
87 VerifyTaskEnvironement(traits); | 87 VerifyTaskEnvironement(traits); |
88 event->Signal(); | 88 event->Signal(); |
89 } | 89 } |
90 | 90 |
| 91 scoped_refptr<TaskRunner> CreateTaskRunnerWithTraitsAndExecutionMode( |
| 92 TaskScheduler* scheduler, |
| 93 const TaskTraits& traits, |
| 94 test::ExecutionMode execution_mode) { |
| 95 switch (execution_mode) { |
| 96 case test::ExecutionMode::PARALLEL: |
| 97 return scheduler->CreateTaskRunnerWithTraits(traits); |
| 98 case test::ExecutionMode::SEQUENCED: |
| 99 return scheduler->CreateSequencedTaskRunnerWithTraits(traits); |
| 100 case test::ExecutionMode::SINGLE_THREADED: |
| 101 return scheduler->CreateSingleThreadTaskRunnerWithTraits(traits); |
| 102 } |
| 103 ADD_FAILURE() << "Unknown ExecutionMode"; |
| 104 return nullptr; |
| 105 } |
| 106 |
91 class ThreadPostingTasks : public SimpleThread { | 107 class ThreadPostingTasks : public SimpleThread { |
92 public: | 108 public: |
93 // Creates a thread that posts Tasks to |scheduler| with |traits| and | 109 // Creates a thread that posts Tasks to |scheduler| with |traits| and |
94 // |execution_mode|. | 110 // |execution_mode|. |
95 ThreadPostingTasks(TaskSchedulerImpl* scheduler, | 111 ThreadPostingTasks(TaskSchedulerImpl* scheduler, |
96 const TaskTraits& traits, | 112 const TaskTraits& traits, |
97 ExecutionMode execution_mode) | 113 test::ExecutionMode execution_mode) |
98 : SimpleThread("ThreadPostingTasks"), | 114 : SimpleThread("ThreadPostingTasks"), |
99 traits_(traits), | 115 traits_(traits), |
100 factory_(scheduler->CreateTaskRunnerWithTraits(traits, execution_mode), | 116 factory_(CreateTaskRunnerWithTraitsAndExecutionMode(scheduler, |
| 117 traits, |
| 118 execution_mode), |
101 execution_mode) {} | 119 execution_mode) {} |
102 | 120 |
103 void WaitForAllTasksToRun() { factory_.WaitForAllTasksToRun(); } | 121 void WaitForAllTasksToRun() { factory_.WaitForAllTasksToRun(); } |
104 | 122 |
105 private: | 123 private: |
106 void Run() override { | 124 void Run() override { |
107 EXPECT_FALSE(factory_.task_runner()->RunsTasksOnCurrentThread()); | 125 EXPECT_FALSE(factory_.task_runner()->RunsTasksOnCurrentThread()); |
108 | 126 |
109 const size_t kNumTasksPerThread = 150; | 127 const size_t kNumTasksPerThread = 150; |
110 for (size_t i = 0; i < kNumTasksPerThread; ++i) { | 128 for (size_t i = 0; i < kNumTasksPerThread; ++i) { |
111 factory_.PostTask(test::TestTaskFactory::PostNestedTask::NO, | 129 factory_.PostTask(test::TestTaskFactory::PostNestedTask::NO, |
112 Bind(&VerifyTaskEnvironement, traits_)); | 130 Bind(&VerifyTaskEnvironement, traits_)); |
113 } | 131 } |
114 } | 132 } |
115 | 133 |
116 const TaskTraits traits_; | 134 const TaskTraits traits_; |
117 test::TestTaskFactory factory_; | 135 test::TestTaskFactory factory_; |
118 | 136 |
119 DISALLOW_COPY_AND_ASSIGN(ThreadPostingTasks); | 137 DISALLOW_COPY_AND_ASSIGN(ThreadPostingTasks); |
120 }; | 138 }; |
121 | 139 |
122 // Returns a vector with a TraitsExecutionModePair for each valid | 140 // Returns a vector with a TraitsExecutionModePair for each valid |
123 // combination of {ExecutionMode, TaskPriority, WithFileIO()}. | 141 // combination of {ExecutionMode, TaskPriority, WithFileIO()}. |
124 std::vector<TraitsExecutionModePair> GetTraitsExecutionModePairs() { | 142 std::vector<TraitsExecutionModePair> GetTraitsExecutionModePairs() { |
125 std::vector<TraitsExecutionModePair> params; | 143 std::vector<TraitsExecutionModePair> params; |
126 | 144 |
127 const ExecutionMode execution_modes[] = {ExecutionMode::PARALLEL, | 145 const test::ExecutionMode execution_modes[] = { |
128 ExecutionMode::SEQUENCED, | 146 test::ExecutionMode::PARALLEL, test::ExecutionMode::SEQUENCED, |
129 ExecutionMode::SINGLE_THREADED}; | 147 test::ExecutionMode::SINGLE_THREADED}; |
130 | 148 |
131 for (ExecutionMode execution_mode : execution_modes) { | 149 for (test::ExecutionMode execution_mode : execution_modes) { |
132 for (size_t priority_index = static_cast<size_t>(TaskPriority::LOWEST); | 150 for (size_t priority_index = static_cast<size_t>(TaskPriority::LOWEST); |
133 priority_index <= static_cast<size_t>(TaskPriority::HIGHEST); | 151 priority_index <= static_cast<size_t>(TaskPriority::HIGHEST); |
134 ++priority_index) { | 152 ++priority_index) { |
135 const TaskPriority priority = static_cast<TaskPriority>(priority_index); | 153 const TaskPriority priority = static_cast<TaskPriority>(priority_index); |
136 params.push_back(TraitsExecutionModePair( | 154 params.push_back(TraitsExecutionModePair( |
137 TaskTraits().WithPriority(priority), execution_mode)); | 155 TaskTraits().WithPriority(priority), execution_mode)); |
138 params.push_back(TraitsExecutionModePair( | 156 params.push_back(TraitsExecutionModePair( |
139 TaskTraits().WithPriority(priority).WithFileIO(), execution_mode)); | 157 TaskTraits().WithPriority(priority).WithFileIO(), execution_mode)); |
140 } | 158 } |
141 } | 159 } |
(...skipping 70 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
212 Bind(&VerifyTaskEnvironementAndSignalEvent, GetParam().traits, | 230 Bind(&VerifyTaskEnvironementAndSignalEvent, GetParam().traits, |
213 Unretained(&task_ran))); | 231 Unretained(&task_ran))); |
214 task_ran.Wait(); | 232 task_ran.Wait(); |
215 } | 233 } |
216 | 234 |
217 // Verifies that Tasks posted via a TaskRunner with parameterized TaskTraits and | 235 // Verifies that Tasks posted via a TaskRunner with parameterized TaskTraits and |
218 // ExecutionMode run on a thread with the expected priority and I/O restrictions | 236 // ExecutionMode run on a thread with the expected priority and I/O restrictions |
219 // and respect the characteristics of their ExecutionMode. | 237 // and respect the characteristics of their ExecutionMode. |
220 TEST_P(TaskSchedulerImplTest, PostTasksViaTaskRunner) { | 238 TEST_P(TaskSchedulerImplTest, PostTasksViaTaskRunner) { |
221 test::TestTaskFactory factory( | 239 test::TestTaskFactory factory( |
222 scheduler_->CreateTaskRunnerWithTraits(GetParam().traits, | 240 CreateTaskRunnerWithTraitsAndExecutionMode( |
223 GetParam().execution_mode), | 241 scheduler_.get(), GetParam().traits, GetParam().execution_mode), |
224 GetParam().execution_mode); | 242 GetParam().execution_mode); |
225 EXPECT_FALSE(factory.task_runner()->RunsTasksOnCurrentThread()); | 243 EXPECT_FALSE(factory.task_runner()->RunsTasksOnCurrentThread()); |
226 | 244 |
227 const size_t kNumTasksPerTest = 150; | 245 const size_t kNumTasksPerTest = 150; |
228 for (size_t i = 0; i < kNumTasksPerTest; ++i) { | 246 for (size_t i = 0; i < kNumTasksPerTest; ++i) { |
229 factory.PostTask(test::TestTaskFactory::PostNestedTask::NO, | 247 factory.PostTask(test::TestTaskFactory::PostNestedTask::NO, |
230 Bind(&VerifyTaskEnvironement, GetParam().traits)); | 248 Bind(&VerifyTaskEnvironement, GetParam().traits)); |
231 } | 249 } |
232 | 250 |
233 factory.WaitForAllTasksToRun(); | 251 factory.WaitForAllTasksToRun(); |
(...skipping 20 matching lines...) Expand all Loading... |
254 thread->WaitForAllTasksToRun(); | 272 thread->WaitForAllTasksToRun(); |
255 thread->Join(); | 273 thread->Join(); |
256 } | 274 } |
257 } | 275 } |
258 | 276 |
259 // TODO(fdoray): Add tests with Sequences that move around worker pools once | 277 // TODO(fdoray): Add tests with Sequences that move around worker pools once |
260 // child TaskRunners are supported. | 278 // child TaskRunners are supported. |
261 | 279 |
262 } // namespace internal | 280 } // namespace internal |
263 } // namespace base | 281 } // namespace base |
OLD | NEW |