OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 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 "platform/scheduler/base/work_queue.h" | 5 #include "platform/scheduler/base/work_queue.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "base/memory/ptr_util.h" | 10 #include "base/memory/ptr_util.h" |
(...skipping 19 matching lines...) Expand all Loading... |
30 | 30 |
31 work_queue_.reset(new WorkQueue(task_queue_.get(), "test", | 31 work_queue_.reset(new WorkQueue(task_queue_.get(), "test", |
32 WorkQueue::QueueType::IMMEDIATE)); | 32 WorkQueue::QueueType::IMMEDIATE)); |
33 work_queue_sets_.reset(new WorkQueueSets(1, "test")); | 33 work_queue_sets_.reset(new WorkQueueSets(1, "test")); |
34 work_queue_sets_->AddQueue(work_queue_.get(), 0); | 34 work_queue_sets_->AddQueue(work_queue_.get(), 0); |
35 } | 35 } |
36 | 36 |
37 void TearDown() override { work_queue_sets_->RemoveQueue(work_queue_.get()); } | 37 void TearDown() override { work_queue_sets_->RemoveQueue(work_queue_.get()); } |
38 | 38 |
39 protected: | 39 protected: |
40 TaskQueueImpl::Task FakeTaskWithEnqueueOrder(int enqueue_order) { | 40 TaskQueueImpl::Task FakeTaskWithSequenceNum(SequenceNumber sequence_num) { |
41 TaskQueueImpl::Task fake_task(FROM_HERE, base::Bind(&NopTask), | 41 TaskQueueImpl::Task fake_task(FROM_HERE, base::Bind(&NopTask), |
42 base::TimeTicks(), 0, true); | 42 {base::TimeTicks(), sequence_num}, true); |
43 fake_task.set_enqueue_order(enqueue_order); | |
44 return fake_task; | 43 return fake_task; |
45 } | 44 } |
46 | 45 |
47 std::unique_ptr<RealTimeDomain> time_domain_; | 46 std::unique_ptr<RealTimeDomain> time_domain_; |
48 scoped_refptr<TaskQueueImpl> task_queue_; | 47 scoped_refptr<TaskQueueImpl> task_queue_; |
49 std::unique_ptr<WorkQueue> work_queue_; | 48 std::unique_ptr<WorkQueue> work_queue_; |
50 std::unique_ptr<WorkQueueSets> work_queue_sets_; | 49 std::unique_ptr<WorkQueueSets> work_queue_sets_; |
51 std::unique_ptr<WTF::Deque<TaskQueueImpl::Task>> incoming_queue_; | 50 std::unique_ptr<WTF::Deque<TaskQueueImpl::Task>> incoming_queue_; |
52 }; | 51 }; |
53 | 52 |
54 TEST_F(WorkQueueTest, Empty) { | 53 TEST_F(WorkQueueTest, Empty) { |
55 EXPECT_TRUE(work_queue_->Empty()); | 54 EXPECT_TRUE(work_queue_->Empty()); |
56 work_queue_->Push(FakeTaskWithEnqueueOrder(1)); | 55 work_queue_->Push(FakeTaskWithSequenceNum(1)); |
57 EXPECT_FALSE(work_queue_->Empty()); | 56 EXPECT_FALSE(work_queue_->Empty()); |
58 } | 57 } |
59 | 58 |
60 TEST_F(WorkQueueTest, Empty_IgnoresFences) { | 59 TEST_F(WorkQueueTest, Empty_IgnoresFences) { |
61 work_queue_->Push(FakeTaskWithEnqueueOrder(1)); | 60 work_queue_->Push(FakeTaskWithSequenceNum(1)); |
62 work_queue_->InsertFence(1); | 61 work_queue_->InsertFence(1); |
63 EXPECT_FALSE(work_queue_->Empty()); | 62 EXPECT_FALSE(work_queue_->Empty()); |
64 } | 63 } |
65 | 64 |
66 TEST_F(WorkQueueTest, GetFrontTaskEnqueueOrderQueueEmpty) { | 65 TEST_F(WorkQueueTest, GetFrontTaskEnqueueOrderQueueEmpty) { |
67 EnqueueOrder enqueue_order; | 66 EnqueueOrder enqueue_order; |
68 EXPECT_FALSE(work_queue_->GetFrontTaskEnqueueOrder(&enqueue_order)); | 67 EXPECT_FALSE(work_queue_->GetFrontTaskEnqueueOrder(&enqueue_order)); |
69 } | 68 } |
70 | 69 |
71 TEST_F(WorkQueueTest, GetFrontTaskEnqueueOrder) { | 70 TEST_F(WorkQueueTest, GetFrontTaskEnqueueOrder) { |
72 work_queue_->Push(FakeTaskWithEnqueueOrder(2)); | 71 work_queue_->Push(FakeTaskWithSequenceNum(2)); |
73 work_queue_->Push(FakeTaskWithEnqueueOrder(3)); | 72 work_queue_->Push(FakeTaskWithSequenceNum(3)); |
74 work_queue_->Push(FakeTaskWithEnqueueOrder(4)); | 73 work_queue_->Push(FakeTaskWithSequenceNum(4)); |
75 | 74 |
76 EnqueueOrder enqueue_order; | 75 EnqueueOrder enqueue_order; |
77 EXPECT_TRUE(work_queue_->GetFrontTaskEnqueueOrder(&enqueue_order)); | 76 EXPECT_TRUE(work_queue_->GetFrontTaskEnqueueOrder(&enqueue_order)); |
78 EXPECT_EQ(2ull, enqueue_order); | 77 EXPECT_EQ(2ull, enqueue_order.sequence_num); |
79 } | 78 } |
80 | 79 |
81 TEST_F(WorkQueueTest, GetFrontTaskQueueEmpty) { | 80 TEST_F(WorkQueueTest, GetFrontTaskQueueEmpty) { |
82 EXPECT_EQ(nullptr, work_queue_->GetFrontTask()); | 81 EXPECT_EQ(nullptr, work_queue_->GetFrontTask()); |
83 } | 82 } |
84 | 83 |
85 TEST_F(WorkQueueTest, GetFrontTask) { | 84 TEST_F(WorkQueueTest, GetFrontTask) { |
86 work_queue_->Push(FakeTaskWithEnqueueOrder(2)); | 85 work_queue_->Push(FakeTaskWithSequenceNum(2)); |
87 work_queue_->Push(FakeTaskWithEnqueueOrder(3)); | 86 work_queue_->Push(FakeTaskWithSequenceNum(3)); |
88 work_queue_->Push(FakeTaskWithEnqueueOrder(4)); | 87 work_queue_->Push(FakeTaskWithSequenceNum(4)); |
89 | 88 |
90 ASSERT_NE(nullptr, work_queue_->GetFrontTask()); | 89 ASSERT_NE(nullptr, work_queue_->GetFrontTask()); |
91 EXPECT_EQ(2ull, work_queue_->GetFrontTask()->enqueue_order()); | 90 EXPECT_EQ(2ull, work_queue_->GetFrontTask()->enqueue_order().sequence_num); |
92 } | 91 } |
93 | 92 |
94 TEST_F(WorkQueueTest, GetBackTask_Empty) { | 93 TEST_F(WorkQueueTest, GetBackTask_Empty) { |
95 EXPECT_EQ(nullptr, work_queue_->GetBackTask()); | 94 EXPECT_EQ(nullptr, work_queue_->GetBackTask()); |
96 } | 95 } |
97 | 96 |
98 TEST_F(WorkQueueTest, GetBackTask) { | 97 TEST_F(WorkQueueTest, GetBackTask) { |
99 work_queue_->Push(FakeTaskWithEnqueueOrder(2)); | 98 work_queue_->Push(FakeTaskWithSequenceNum(2)); |
100 work_queue_->Push(FakeTaskWithEnqueueOrder(3)); | 99 work_queue_->Push(FakeTaskWithSequenceNum(3)); |
101 work_queue_->Push(FakeTaskWithEnqueueOrder(4)); | 100 work_queue_->Push(FakeTaskWithSequenceNum(4)); |
102 | 101 |
103 ASSERT_NE(nullptr, work_queue_->GetBackTask()); | 102 ASSERT_NE(nullptr, work_queue_->GetBackTask()); |
104 EXPECT_EQ(4ull, work_queue_->GetBackTask()->enqueue_order()); | 103 EXPECT_EQ(4ull, work_queue_->GetBackTask()->enqueue_order().sequence_num); |
105 } | 104 } |
106 | 105 |
107 TEST_F(WorkQueueTest, Push) { | 106 TEST_F(WorkQueueTest, Push) { |
108 WorkQueue* work_queue; | 107 WorkQueue* work_queue; |
109 EXPECT_FALSE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue)); | 108 EXPECT_FALSE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue)); |
110 | 109 |
111 work_queue_->Push(FakeTaskWithEnqueueOrder(2)); | 110 work_queue_->Push(FakeTaskWithSequenceNum(2)); |
112 EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue)); | 111 EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue)); |
113 EXPECT_EQ(work_queue_.get(), work_queue); | 112 EXPECT_EQ(work_queue_.get(), work_queue); |
114 } | 113 } |
115 | 114 |
116 TEST_F(WorkQueueTest, PushAfterFenceHit) { | 115 TEST_F(WorkQueueTest, PushAfterFenceHit) { |
117 work_queue_->InsertFence(1); | 116 work_queue_->InsertFence(1); |
118 WorkQueue* work_queue; | 117 WorkQueue* work_queue; |
119 EXPECT_FALSE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue)); | 118 EXPECT_FALSE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue)); |
120 | 119 |
121 work_queue_->Push(FakeTaskWithEnqueueOrder(2)); | 120 work_queue_->Push(FakeTaskWithSequenceNum(2)); |
122 EXPECT_FALSE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue)); | 121 EXPECT_FALSE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue)); |
123 } | 122 } |
124 | 123 |
125 TEST_F(WorkQueueTest, ReloadEmptyImmediateQueue) { | 124 TEST_F(WorkQueueTest, ReloadEmptyImmediateQueue) { |
126 task_queue_->PushImmediateIncomingTaskForTest(FakeTaskWithEnqueueOrder(2)); | 125 task_queue_->PushImmediateIncomingTaskForTest(FakeTaskWithSequenceNum(2)); |
127 task_queue_->PushImmediateIncomingTaskForTest(FakeTaskWithEnqueueOrder(3)); | 126 task_queue_->PushImmediateIncomingTaskForTest(FakeTaskWithSequenceNum(3)); |
128 task_queue_->PushImmediateIncomingTaskForTest(FakeTaskWithEnqueueOrder(4)); | 127 task_queue_->PushImmediateIncomingTaskForTest(FakeTaskWithSequenceNum(4)); |
129 | 128 |
130 WorkQueue* work_queue; | 129 WorkQueue* work_queue; |
131 EXPECT_FALSE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue)); | 130 EXPECT_FALSE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue)); |
132 EXPECT_TRUE(work_queue_->Empty()); | 131 EXPECT_TRUE(work_queue_->Empty()); |
133 work_queue_->ReloadEmptyImmediateQueue(); | 132 work_queue_->ReloadEmptyImmediateQueue(); |
134 | 133 |
135 EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue)); | 134 EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue)); |
136 EXPECT_FALSE(work_queue_->Empty()); | 135 EXPECT_FALSE(work_queue_->Empty()); |
137 | 136 |
138 ASSERT_NE(nullptr, work_queue_->GetFrontTask()); | 137 ASSERT_NE(nullptr, work_queue_->GetFrontTask()); |
139 EXPECT_EQ(2ull, work_queue_->GetFrontTask()->enqueue_order()); | 138 EXPECT_EQ(2ull, work_queue_->GetFrontTask()->enqueue_order().sequence_num); |
140 | 139 |
141 ASSERT_NE(nullptr, work_queue_->GetBackTask()); | 140 ASSERT_NE(nullptr, work_queue_->GetBackTask()); |
142 EXPECT_EQ(4ull, work_queue_->GetBackTask()->enqueue_order()); | 141 EXPECT_EQ(4ull, work_queue_->GetBackTask()->enqueue_order().sequence_num); |
143 } | 142 } |
144 | 143 |
145 TEST_F(WorkQueueTest, ReloadEmptyImmediateQueueAfterFenceHit) { | 144 TEST_F(WorkQueueTest, ReloadEmptyImmediateQueueAfterFenceHit) { |
146 work_queue_->InsertFence(1); | 145 work_queue_->InsertFence(1); |
147 task_queue_->PushImmediateIncomingTaskForTest(FakeTaskWithEnqueueOrder(2)); | 146 task_queue_->PushImmediateIncomingTaskForTest(FakeTaskWithSequenceNum(2)); |
148 task_queue_->PushImmediateIncomingTaskForTest(FakeTaskWithEnqueueOrder(3)); | 147 task_queue_->PushImmediateIncomingTaskForTest(FakeTaskWithSequenceNum(3)); |
149 task_queue_->PushImmediateIncomingTaskForTest(FakeTaskWithEnqueueOrder(4)); | 148 task_queue_->PushImmediateIncomingTaskForTest(FakeTaskWithSequenceNum(4)); |
150 | 149 |
151 WorkQueue* work_queue; | 150 WorkQueue* work_queue; |
152 EXPECT_FALSE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue)); | 151 EXPECT_FALSE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue)); |
153 EXPECT_TRUE(work_queue_->Empty()); | 152 EXPECT_TRUE(work_queue_->Empty()); |
154 work_queue_->ReloadEmptyImmediateQueue(); | 153 work_queue_->ReloadEmptyImmediateQueue(); |
155 | 154 |
156 EXPECT_FALSE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue)); | 155 EXPECT_FALSE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue)); |
157 EXPECT_FALSE(work_queue_->Empty()); | 156 EXPECT_FALSE(work_queue_->Empty()); |
158 | 157 |
159 ASSERT_NE(nullptr, work_queue_->GetFrontTask()); | 158 ASSERT_NE(nullptr, work_queue_->GetFrontTask()); |
160 EXPECT_EQ(2ull, work_queue_->GetFrontTask()->enqueue_order()); | 159 EXPECT_EQ(2ull, work_queue_->GetFrontTask()->enqueue_order().sequence_num); |
161 | 160 |
162 ASSERT_NE(nullptr, work_queue_->GetBackTask()); | 161 ASSERT_NE(nullptr, work_queue_->GetBackTask()); |
163 EXPECT_EQ(4ull, work_queue_->GetBackTask()->enqueue_order()); | 162 EXPECT_EQ(4ull, work_queue_->GetBackTask()->enqueue_order().sequence_num); |
164 } | 163 } |
165 | 164 |
166 TEST_F(WorkQueueTest, TakeTaskFromWorkQueue) { | 165 TEST_F(WorkQueueTest, TakeTaskFromWorkQueue) { |
167 work_queue_->Push(FakeTaskWithEnqueueOrder(2)); | 166 work_queue_->Push(FakeTaskWithSequenceNum(2)); |
168 work_queue_->Push(FakeTaskWithEnqueueOrder(3)); | 167 work_queue_->Push(FakeTaskWithSequenceNum(3)); |
169 work_queue_->Push(FakeTaskWithEnqueueOrder(4)); | 168 work_queue_->Push(FakeTaskWithSequenceNum(4)); |
170 | 169 |
171 WorkQueue* work_queue; | 170 WorkQueue* work_queue; |
172 EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue)); | 171 EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue)); |
173 EXPECT_FALSE(work_queue_->Empty()); | 172 EXPECT_FALSE(work_queue_->Empty()); |
174 | 173 |
175 EXPECT_EQ(2ull, work_queue_->TakeTaskFromWorkQueue().enqueue_order()); | 174 EXPECT_EQ(2ull, |
176 EXPECT_EQ(3ull, work_queue_->TakeTaskFromWorkQueue().enqueue_order()); | 175 work_queue_->TakeTaskFromWorkQueue().enqueue_order().sequence_num); |
177 EXPECT_EQ(4ull, work_queue_->TakeTaskFromWorkQueue().enqueue_order()); | 176 EXPECT_EQ(3ull, |
| 177 work_queue_->TakeTaskFromWorkQueue().enqueue_order().sequence_num); |
| 178 EXPECT_EQ(4ull, |
| 179 work_queue_->TakeTaskFromWorkQueue().enqueue_order().sequence_num); |
178 | 180 |
179 EXPECT_FALSE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue)); | 181 EXPECT_FALSE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue)); |
180 EXPECT_TRUE(work_queue_->Empty()); | 182 EXPECT_TRUE(work_queue_->Empty()); |
181 } | 183 } |
182 | 184 |
183 TEST_F(WorkQueueTest, TakeTaskFromWorkQueue_HitFence) { | 185 TEST_F(WorkQueueTest, TakeTaskFromWorkQueue_HitFence) { |
184 work_queue_->InsertFence(3); | 186 work_queue_->InsertFence(3); |
185 work_queue_->Push(FakeTaskWithEnqueueOrder(2)); | 187 work_queue_->Push(FakeTaskWithSequenceNum(2)); |
186 work_queue_->Push(FakeTaskWithEnqueueOrder(4)); | 188 work_queue_->Push(FakeTaskWithSequenceNum(4)); |
187 EXPECT_FALSE(work_queue_->BlockedByFence()); | 189 EXPECT_FALSE(work_queue_->BlockedByFence()); |
188 | 190 |
189 WorkQueue* work_queue; | 191 WorkQueue* work_queue; |
190 EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue)); | 192 EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue)); |
191 EXPECT_FALSE(work_queue_->Empty()); | 193 EXPECT_FALSE(work_queue_->Empty()); |
192 EXPECT_FALSE(work_queue_->BlockedByFence()); | 194 EXPECT_FALSE(work_queue_->BlockedByFence()); |
193 | 195 |
194 EXPECT_EQ(2ull, work_queue_->TakeTaskFromWorkQueue().enqueue_order()); | 196 EXPECT_EQ(2ull, |
| 197 work_queue_->TakeTaskFromWorkQueue().enqueue_order().sequence_num); |
195 EXPECT_FALSE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue)); | 198 EXPECT_FALSE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue)); |
196 EXPECT_FALSE(work_queue_->Empty()); | 199 EXPECT_FALSE(work_queue_->Empty()); |
197 EXPECT_TRUE(work_queue_->BlockedByFence()); | 200 EXPECT_TRUE(work_queue_->BlockedByFence()); |
198 } | 201 } |
199 | 202 |
200 TEST_F(WorkQueueTest, InsertFenceBeforeEnqueueing) { | 203 TEST_F(WorkQueueTest, InsertFenceBeforeEnqueueing) { |
201 EXPECT_FALSE(work_queue_->InsertFence(1)); | 204 EXPECT_FALSE(work_queue_->InsertFence(1)); |
202 EXPECT_TRUE(work_queue_->BlockedByFence()); | 205 EXPECT_TRUE(work_queue_->BlockedByFence()); |
203 | 206 |
204 work_queue_->Push(FakeTaskWithEnqueueOrder(2)); | 207 work_queue_->Push(FakeTaskWithSequenceNum(2)); |
205 work_queue_->Push(FakeTaskWithEnqueueOrder(3)); | 208 work_queue_->Push(FakeTaskWithSequenceNum(3)); |
206 work_queue_->Push(FakeTaskWithEnqueueOrder(4)); | 209 work_queue_->Push(FakeTaskWithSequenceNum(4)); |
207 | 210 |
208 EnqueueOrder enqueue_order; | 211 EnqueueOrder enqueue_order; |
209 EXPECT_FALSE(work_queue_->GetFrontTaskEnqueueOrder(&enqueue_order)); | 212 EXPECT_FALSE(work_queue_->GetFrontTaskEnqueueOrder(&enqueue_order)); |
210 } | 213 } |
211 | 214 |
212 TEST_F(WorkQueueTest, InsertFenceAfterEnqueueingNonBlocking) { | 215 TEST_F(WorkQueueTest, InsertFenceAfterEnqueueingNonBlocking) { |
213 work_queue_->Push(FakeTaskWithEnqueueOrder(2)); | 216 work_queue_->Push(FakeTaskWithSequenceNum(2)); |
214 work_queue_->Push(FakeTaskWithEnqueueOrder(3)); | 217 work_queue_->Push(FakeTaskWithSequenceNum(3)); |
215 work_queue_->Push(FakeTaskWithEnqueueOrder(4)); | 218 work_queue_->Push(FakeTaskWithSequenceNum(4)); |
216 | 219 |
217 EXPECT_FALSE(work_queue_->InsertFence(5)); | 220 EXPECT_FALSE(work_queue_->InsertFence(5)); |
218 EXPECT_FALSE(work_queue_->BlockedByFence()); | 221 EXPECT_FALSE(work_queue_->BlockedByFence()); |
219 | 222 |
220 EnqueueOrder enqueue_order; | 223 EnqueueOrder enqueue_order; |
221 EXPECT_TRUE(work_queue_->GetFrontTaskEnqueueOrder(&enqueue_order)); | 224 EXPECT_TRUE(work_queue_->GetFrontTaskEnqueueOrder(&enqueue_order)); |
222 EXPECT_EQ(2ull, work_queue_->TakeTaskFromWorkQueue().enqueue_order()); | 225 EXPECT_EQ(2ull, |
| 226 work_queue_->TakeTaskFromWorkQueue().enqueue_order().sequence_num); |
223 } | 227 } |
224 | 228 |
225 TEST_F(WorkQueueTest, InsertFenceAfterEnqueueing) { | 229 TEST_F(WorkQueueTest, InsertFenceAfterEnqueueing) { |
226 work_queue_->Push(FakeTaskWithEnqueueOrder(2)); | 230 work_queue_->Push(FakeTaskWithSequenceNum(2)); |
227 work_queue_->Push(FakeTaskWithEnqueueOrder(3)); | 231 work_queue_->Push(FakeTaskWithSequenceNum(3)); |
228 work_queue_->Push(FakeTaskWithEnqueueOrder(4)); | 232 work_queue_->Push(FakeTaskWithSequenceNum(4)); |
229 | 233 |
230 // NB in reality a fence will always be greater than any currently enqueued | 234 // NB in reality a fence will always be greater than any currently enqueued |
231 // tasks. | 235 // tasks. |
232 EXPECT_FALSE(work_queue_->InsertFence(1)); | 236 EXPECT_FALSE(work_queue_->InsertFence(1)); |
233 EXPECT_TRUE(work_queue_->BlockedByFence()); | 237 EXPECT_TRUE(work_queue_->BlockedByFence()); |
234 | 238 |
235 EnqueueOrder enqueue_order; | 239 EnqueueOrder enqueue_order; |
236 EXPECT_FALSE(work_queue_->GetFrontTaskEnqueueOrder(&enqueue_order)); | 240 EXPECT_FALSE(work_queue_->GetFrontTaskEnqueueOrder(&enqueue_order)); |
237 } | 241 } |
238 | 242 |
239 TEST_F(WorkQueueTest, InsertNewFence) { | 243 TEST_F(WorkQueueTest, InsertNewFence) { |
240 work_queue_->Push(FakeTaskWithEnqueueOrder(2)); | 244 work_queue_->Push(FakeTaskWithSequenceNum(2)); |
241 work_queue_->Push(FakeTaskWithEnqueueOrder(4)); | 245 work_queue_->Push(FakeTaskWithSequenceNum(4)); |
242 work_queue_->Push(FakeTaskWithEnqueueOrder(5)); | 246 work_queue_->Push(FakeTaskWithSequenceNum(5)); |
243 | 247 |
244 EXPECT_FALSE(work_queue_->InsertFence(3)); | 248 EXPECT_FALSE(work_queue_->InsertFence(3)); |
245 EXPECT_FALSE(work_queue_->BlockedByFence()); | 249 EXPECT_FALSE(work_queue_->BlockedByFence()); |
246 | 250 |
247 // Note until TakeTaskFromWorkQueue() is called we don't hit the fence. | 251 // Note until TakeTaskFromWorkQueue() is called we don't hit the fence. |
248 EnqueueOrder enqueue_order; | 252 EnqueueOrder enqueue_order; |
249 EXPECT_TRUE(work_queue_->GetFrontTaskEnqueueOrder(&enqueue_order)); | 253 EXPECT_TRUE(work_queue_->GetFrontTaskEnqueueOrder(&enqueue_order)); |
250 EXPECT_EQ(2ull, enqueue_order); | 254 EXPECT_EQ(2ull, enqueue_order.sequence_num); |
251 | 255 |
252 EXPECT_EQ(2ull, work_queue_->TakeTaskFromWorkQueue().enqueue_order()); | 256 EXPECT_EQ(2ull, |
| 257 work_queue_->TakeTaskFromWorkQueue().enqueue_order().sequence_num); |
253 EXPECT_FALSE(work_queue_->GetFrontTaskEnqueueOrder(&enqueue_order)); | 258 EXPECT_FALSE(work_queue_->GetFrontTaskEnqueueOrder(&enqueue_order)); |
254 EXPECT_TRUE(work_queue_->BlockedByFence()); | 259 EXPECT_TRUE(work_queue_->BlockedByFence()); |
255 | 260 |
256 // Inserting the new fence should temporarily unblock the queue until the new | 261 // Inserting the new fence should temporarily unblock the queue until the new |
257 // one is hit. | 262 // one is hit. |
258 EXPECT_TRUE(work_queue_->InsertFence(6)); | 263 EXPECT_TRUE(work_queue_->InsertFence(6)); |
259 EXPECT_FALSE(work_queue_->BlockedByFence()); | 264 EXPECT_FALSE(work_queue_->BlockedByFence()); |
260 | 265 |
261 EXPECT_TRUE(work_queue_->GetFrontTaskEnqueueOrder(&enqueue_order)); | 266 EXPECT_TRUE(work_queue_->GetFrontTaskEnqueueOrder(&enqueue_order)); |
262 EXPECT_EQ(4ull, enqueue_order); | 267 EXPECT_EQ(4ull, enqueue_order.sequence_num); |
263 EXPECT_EQ(4ull, work_queue_->TakeTaskFromWorkQueue().enqueue_order()); | 268 EXPECT_EQ(4ull, |
| 269 work_queue_->TakeTaskFromWorkQueue().enqueue_order().sequence_num); |
264 EXPECT_TRUE(work_queue_->GetFrontTaskEnqueueOrder(&enqueue_order)); | 270 EXPECT_TRUE(work_queue_->GetFrontTaskEnqueueOrder(&enqueue_order)); |
265 EXPECT_FALSE(work_queue_->BlockedByFence()); | 271 EXPECT_FALSE(work_queue_->BlockedByFence()); |
266 } | 272 } |
267 | 273 |
268 TEST_F(WorkQueueTest, PushWithNonEmptyQueueDoesNotHitFence) { | 274 TEST_F(WorkQueueTest, PushWithNonEmptyQueueDoesNotHitFence) { |
269 work_queue_->Push(FakeTaskWithEnqueueOrder(1)); | 275 work_queue_->Push(FakeTaskWithSequenceNum(1)); |
270 EXPECT_FALSE(work_queue_->InsertFence(2)); | 276 EXPECT_FALSE(work_queue_->InsertFence(2)); |
271 work_queue_->Push(FakeTaskWithEnqueueOrder(3)); | 277 work_queue_->Push(FakeTaskWithSequenceNum(3)); |
272 EXPECT_FALSE(work_queue_->BlockedByFence()); | 278 EXPECT_FALSE(work_queue_->BlockedByFence()); |
273 } | 279 } |
274 | 280 |
275 TEST_F(WorkQueueTest, RemoveFence) { | 281 TEST_F(WorkQueueTest, RemoveFence) { |
276 work_queue_->Push(FakeTaskWithEnqueueOrder(2)); | 282 work_queue_->Push(FakeTaskWithSequenceNum(2)); |
277 work_queue_->Push(FakeTaskWithEnqueueOrder(4)); | 283 work_queue_->Push(FakeTaskWithSequenceNum(4)); |
278 work_queue_->Push(FakeTaskWithEnqueueOrder(5)); | 284 work_queue_->Push(FakeTaskWithSequenceNum(5)); |
279 work_queue_->InsertFence(3); | 285 work_queue_->InsertFence(3); |
280 | 286 |
281 WorkQueue* work_queue; | 287 WorkQueue* work_queue; |
282 EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue)); | 288 EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue)); |
283 EXPECT_FALSE(work_queue_->Empty()); | 289 EXPECT_FALSE(work_queue_->Empty()); |
284 | 290 |
285 EXPECT_EQ(2ull, work_queue_->TakeTaskFromWorkQueue().enqueue_order()); | 291 EXPECT_EQ(2ull, |
| 292 work_queue_->TakeTaskFromWorkQueue().enqueue_order().sequence_num); |
286 EXPECT_FALSE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue)); | 293 EXPECT_FALSE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue)); |
287 EXPECT_FALSE(work_queue_->Empty()); | 294 EXPECT_FALSE(work_queue_->Empty()); |
288 EXPECT_TRUE(work_queue_->BlockedByFence()); | 295 EXPECT_TRUE(work_queue_->BlockedByFence()); |
289 | 296 |
290 EXPECT_TRUE(work_queue_->RemoveFence()); | 297 EXPECT_TRUE(work_queue_->RemoveFence()); |
291 EXPECT_EQ(4ull, work_queue_->TakeTaskFromWorkQueue().enqueue_order()); | 298 EXPECT_EQ(4ull, |
| 299 work_queue_->TakeTaskFromWorkQueue().enqueue_order().sequence_num); |
292 EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue)); | 300 EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue)); |
293 EXPECT_FALSE(work_queue_->BlockedByFence()); | 301 EXPECT_FALSE(work_queue_->BlockedByFence()); |
294 } | 302 } |
295 | 303 |
296 TEST_F(WorkQueueTest, RemoveFenceButNoFence) { | 304 TEST_F(WorkQueueTest, RemoveFenceButNoFence) { |
297 EXPECT_FALSE(work_queue_->RemoveFence()); | 305 EXPECT_FALSE(work_queue_->RemoveFence()); |
298 } | 306 } |
299 | 307 |
300 TEST_F(WorkQueueTest, RemoveFenceNothingUnblocked) { | 308 TEST_F(WorkQueueTest, RemoveFenceNothingUnblocked) { |
301 EXPECT_FALSE(work_queue_->InsertFence(1)); | 309 EXPECT_FALSE(work_queue_->InsertFence(1)); |
302 EXPECT_TRUE(work_queue_->BlockedByFence()); | 310 EXPECT_TRUE(work_queue_->BlockedByFence()); |
303 | 311 |
304 EXPECT_FALSE(work_queue_->RemoveFence()); | 312 EXPECT_FALSE(work_queue_->RemoveFence()); |
305 EXPECT_FALSE(work_queue_->BlockedByFence()); | 313 EXPECT_FALSE(work_queue_->BlockedByFence()); |
306 } | 314 } |
307 | 315 |
308 TEST_F(WorkQueueTest, BlockedByFence) { | 316 TEST_F(WorkQueueTest, BlockedByFence) { |
309 EXPECT_FALSE(work_queue_->BlockedByFence()); | 317 EXPECT_FALSE(work_queue_->BlockedByFence()); |
310 EXPECT_FALSE(work_queue_->InsertFence(1)); | 318 EXPECT_FALSE(work_queue_->InsertFence(1)); |
311 EXPECT_TRUE(work_queue_->BlockedByFence()); | 319 EXPECT_TRUE(work_queue_->BlockedByFence()); |
312 } | 320 } |
313 | 321 |
314 TEST_F(WorkQueueTest, BlockedByFencePopBecomesEmpty) { | 322 TEST_F(WorkQueueTest, BlockedByFencePopBecomesEmpty) { |
315 work_queue_->Push(FakeTaskWithEnqueueOrder(1)); | 323 work_queue_->Push(FakeTaskWithSequenceNum(1)); |
316 EXPECT_FALSE(work_queue_->InsertFence(2)); | 324 EXPECT_FALSE(work_queue_->InsertFence(2)); |
317 EXPECT_FALSE(work_queue_->BlockedByFence()); | 325 EXPECT_FALSE(work_queue_->BlockedByFence()); |
318 | 326 |
319 EXPECT_EQ(1ull, work_queue_->TakeTaskFromWorkQueue().enqueue_order()); | 327 EXPECT_EQ(1ull, |
| 328 work_queue_->TakeTaskFromWorkQueue().enqueue_order().sequence_num); |
320 EXPECT_TRUE(work_queue_->BlockedByFence()); | 329 EXPECT_TRUE(work_queue_->BlockedByFence()); |
321 } | 330 } |
322 | 331 |
323 TEST_F(WorkQueueTest, BlockedByFencePop) { | 332 TEST_F(WorkQueueTest, BlockedByFencePop) { |
324 work_queue_->Push(FakeTaskWithEnqueueOrder(1)); | 333 work_queue_->Push(FakeTaskWithSequenceNum(1)); |
325 EXPECT_FALSE(work_queue_->InsertFence(2)); | 334 EXPECT_FALSE(work_queue_->InsertFence(2)); |
326 EXPECT_FALSE(work_queue_->BlockedByFence()); | 335 EXPECT_FALSE(work_queue_->BlockedByFence()); |
327 | 336 |
328 work_queue_->Push(FakeTaskWithEnqueueOrder(3)); | 337 work_queue_->Push(FakeTaskWithSequenceNum(3)); |
329 EXPECT_FALSE(work_queue_->BlockedByFence()); | 338 EXPECT_FALSE(work_queue_->BlockedByFence()); |
330 | 339 |
331 EXPECT_EQ(1ull, work_queue_->TakeTaskFromWorkQueue().enqueue_order()); | 340 EXPECT_EQ(1ull, |
| 341 work_queue_->TakeTaskFromWorkQueue().enqueue_order().sequence_num); |
332 EXPECT_TRUE(work_queue_->BlockedByFence()); | 342 EXPECT_TRUE(work_queue_->BlockedByFence()); |
333 } | 343 } |
334 | 344 |
335 TEST_F(WorkQueueTest, InitiallyEmptyBlockedByFenceNewFenceUnblocks) { | 345 TEST_F(WorkQueueTest, InitiallyEmptyBlockedByFenceNewFenceUnblocks) { |
336 EXPECT_FALSE(work_queue_->InsertFence(1)); | 346 EXPECT_FALSE(work_queue_->InsertFence(1)); |
337 EXPECT_TRUE(work_queue_->BlockedByFence()); | 347 EXPECT_TRUE(work_queue_->BlockedByFence()); |
338 | 348 |
339 work_queue_->Push(FakeTaskWithEnqueueOrder(2)); | 349 work_queue_->Push(FakeTaskWithSequenceNum(2)); |
340 EXPECT_TRUE(work_queue_->InsertFence(3)); | 350 EXPECT_TRUE(work_queue_->InsertFence(3)); |
341 EXPECT_FALSE(work_queue_->BlockedByFence()); | 351 EXPECT_FALSE(work_queue_->BlockedByFence()); |
342 } | 352 } |
343 | 353 |
344 TEST_F(WorkQueueTest, BlockedByFenceNewFenceUnblocks) { | 354 TEST_F(WorkQueueTest, BlockedByFenceNewFenceUnblocks) { |
345 work_queue_->Push(FakeTaskWithEnqueueOrder(1)); | 355 work_queue_->Push(FakeTaskWithSequenceNum(1)); |
346 EXPECT_FALSE(work_queue_->InsertFence(2)); | 356 EXPECT_FALSE(work_queue_->InsertFence(2)); |
347 EXPECT_FALSE(work_queue_->BlockedByFence()); | 357 EXPECT_FALSE(work_queue_->BlockedByFence()); |
348 | 358 |
349 work_queue_->Push(FakeTaskWithEnqueueOrder(3)); | 359 work_queue_->Push(FakeTaskWithSequenceNum(3)); |
350 EXPECT_FALSE(work_queue_->BlockedByFence()); | 360 EXPECT_FALSE(work_queue_->BlockedByFence()); |
351 | 361 |
352 EXPECT_EQ(1ull, work_queue_->TakeTaskFromWorkQueue().enqueue_order()); | 362 EXPECT_EQ(1ull, |
| 363 work_queue_->TakeTaskFromWorkQueue().enqueue_order().sequence_num); |
353 EXPECT_TRUE(work_queue_->BlockedByFence()); | 364 EXPECT_TRUE(work_queue_->BlockedByFence()); |
354 | 365 |
355 EXPECT_TRUE(work_queue_->InsertFence(4)); | 366 EXPECT_TRUE(work_queue_->InsertFence(4)); |
356 EXPECT_FALSE(work_queue_->BlockedByFence()); | 367 EXPECT_FALSE(work_queue_->BlockedByFence()); |
357 } | 368 } |
358 | 369 |
359 TEST_F(WorkQueueTest, InsertFenceAfterEnqueuing) { | 370 TEST_F(WorkQueueTest, InsertFenceAfterEnqueuing) { |
360 work_queue_->Push(FakeTaskWithEnqueueOrder(2)); | 371 work_queue_->Push(FakeTaskWithSequenceNum(2)); |
361 work_queue_->Push(FakeTaskWithEnqueueOrder(3)); | 372 work_queue_->Push(FakeTaskWithSequenceNum(3)); |
362 work_queue_->Push(FakeTaskWithEnqueueOrder(4)); | 373 work_queue_->Push(FakeTaskWithSequenceNum(4)); |
363 EXPECT_FALSE(work_queue_->BlockedByFence()); | 374 EXPECT_FALSE(work_queue_->BlockedByFence()); |
364 | 375 |
365 EXPECT_FALSE(work_queue_->InsertFence(1)); | 376 EXPECT_FALSE(work_queue_->InsertFence(1)); |
366 EXPECT_TRUE(work_queue_->BlockedByFence()); | 377 EXPECT_TRUE(work_queue_->BlockedByFence()); |
367 | 378 |
368 EnqueueOrder enqueue_order; | 379 EnqueueOrder enqueue_order; |
369 EXPECT_FALSE(work_queue_->GetFrontTaskEnqueueOrder(&enqueue_order)); | 380 EXPECT_FALSE(work_queue_->GetFrontTaskEnqueueOrder(&enqueue_order)); |
370 } | 381 } |
371 | 382 |
372 } // namespace internal | 383 } // namespace internal |
373 } // namespace scheduler | 384 } // namespace scheduler |
374 } // namespace blink | 385 } // namespace blink |
OLD | NEW |