OLD | NEW |
1 // Copyright (c) 2015 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 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 <stdint.h> | 5 #include <stdint.h> |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
8 #include <queue> | 8 #include <queue> |
9 | 9 |
10 #include "base/bind.h" | 10 #include "base/bind.h" |
(...skipping 10 matching lines...) Expand all Loading... |
21 | 21 |
22 protected: | 22 protected: |
23 // Simple static function which can be used to test callbacks. | 23 // Simple static function which can be used to test callbacks. |
24 static void SetIntegerFunction(int* test, int value) { *test = value; } | 24 static void SetIntegerFunction(int* test, int value) { *test = value; } |
25 | 25 |
26 std::unique_ptr<SyncPointManager> sync_point_manager_; | 26 std::unique_ptr<SyncPointManager> sync_point_manager_; |
27 }; | 27 }; |
28 | 28 |
29 struct SyncPointStream { | 29 struct SyncPointStream { |
30 scoped_refptr<SyncPointOrderData> order_data; | 30 scoped_refptr<SyncPointOrderData> order_data; |
31 std::unique_ptr<SyncPointClient> client; | 31 scoped_refptr<SyncPointClientState> client_state; |
32 std::queue<uint32_t> order_numbers; | 32 std::queue<uint32_t> order_numbers; |
33 | 33 |
34 SyncPointStream(SyncPointManager* sync_point_manager, | 34 SyncPointStream(SyncPointManager* sync_point_manager, |
35 CommandBufferNamespace namespace_id, | 35 CommandBufferNamespace namespace_id, |
36 CommandBufferId command_buffer_id) | 36 CommandBufferId command_buffer_id) |
37 : order_data(SyncPointOrderData::Create()), | 37 : order_data(sync_point_manager->CreateSyncPointOrderData()), |
38 client(base::MakeUnique<SyncPointClient>(sync_point_manager, | 38 client_state(sync_point_manager->CreateSyncPointClientState( |
39 order_data, | 39 namespace_id, |
40 namespace_id, | 40 command_buffer_id, |
41 command_buffer_id)) {} | 41 order_data->sequence_id())) {} |
42 | 42 |
43 ~SyncPointStream() { | 43 ~SyncPointStream() { |
44 order_data->Destroy(); | 44 order_data->Destroy(); |
45 order_data = nullptr; | 45 client_state->Destroy(); |
46 } | 46 } |
47 | 47 |
48 void AllocateOrderNum(SyncPointManager* sync_point_manager) { | 48 void AllocateOrderNum() { |
49 order_numbers.push( | 49 order_numbers.push(order_data->GenerateUnprocessedOrderNumber()); |
50 order_data->GenerateUnprocessedOrderNumber(sync_point_manager)); | |
51 } | 50 } |
52 | 51 |
53 void BeginProcessing() { | 52 void BeginProcessing() { |
54 ASSERT_FALSE(order_numbers.empty()); | 53 ASSERT_FALSE(order_numbers.empty()); |
55 order_data->BeginProcessingOrderNumber(order_numbers.front()); | 54 order_data->BeginProcessingOrderNumber(order_numbers.front()); |
56 } | 55 } |
57 | 56 |
58 void EndProcessing() { | 57 void EndProcessing() { |
59 ASSERT_FALSE(order_numbers.empty()); | 58 ASSERT_FALSE(order_numbers.empty()); |
60 order_data->FinishProcessingOrderNumber(order_numbers.front()); | 59 order_data->FinishProcessingOrderNumber(order_numbers.front()); |
61 order_numbers.pop(); | 60 order_numbers.pop(); |
62 } | 61 } |
63 }; | 62 }; |
64 | 63 |
65 TEST_F(SyncPointManagerTest, BasicSyncPointOrderDataTest) { | 64 TEST_F(SyncPointManagerTest, BasicSyncPointOrderDataTest) { |
66 scoped_refptr<SyncPointOrderData> order_data = SyncPointOrderData::Create(); | 65 scoped_refptr<SyncPointOrderData> order_data = |
| 66 sync_point_manager_->CreateSyncPointOrderData(); |
67 | 67 |
68 EXPECT_EQ(0u, order_data->current_order_num()); | 68 EXPECT_EQ(0u, order_data->current_order_num()); |
69 EXPECT_EQ(0u, order_data->processed_order_num()); | 69 EXPECT_EQ(0u, order_data->processed_order_num()); |
70 EXPECT_EQ(0u, order_data->unprocessed_order_num()); | 70 EXPECT_EQ(0u, order_data->unprocessed_order_num()); |
71 | 71 |
72 uint32_t order_num = | 72 uint32_t order_num = order_data->GenerateUnprocessedOrderNumber(); |
73 order_data->GenerateUnprocessedOrderNumber(sync_point_manager_.get()); | |
74 EXPECT_EQ(1u, order_num); | 73 EXPECT_EQ(1u, order_num); |
75 | 74 |
76 EXPECT_EQ(0u, order_data->current_order_num()); | 75 EXPECT_EQ(0u, order_data->current_order_num()); |
77 EXPECT_EQ(0u, order_data->processed_order_num()); | 76 EXPECT_EQ(0u, order_data->processed_order_num()); |
78 EXPECT_EQ(order_num, order_data->unprocessed_order_num()); | 77 EXPECT_EQ(order_num, order_data->unprocessed_order_num()); |
79 | 78 |
80 order_data->BeginProcessingOrderNumber(order_num); | 79 order_data->BeginProcessingOrderNumber(order_num); |
81 EXPECT_EQ(order_num, order_data->current_order_num()); | 80 EXPECT_EQ(order_num, order_data->current_order_num()); |
82 EXPECT_EQ(0u, order_data->processed_order_num()); | 81 EXPECT_EQ(0u, order_data->processed_order_num()); |
83 EXPECT_EQ(order_num, order_data->unprocessed_order_num()); | 82 EXPECT_EQ(order_num, order_data->unprocessed_order_num()); |
(...skipping 17 matching lines...) Expand all Loading... |
101 CommandBufferId kBufferId = CommandBufferId::FromUnsafeValue(0x123); | 100 CommandBufferId kBufferId = CommandBufferId::FromUnsafeValue(0x123); |
102 | 101 |
103 uint64_t release_count = 1; | 102 uint64_t release_count = 1; |
104 SyncToken sync_token(kNamespaceId, 0, kBufferId, release_count); | 103 SyncToken sync_token(kNamespaceId, 0, kBufferId, release_count); |
105 | 104 |
106 // Can't wait for sync token before client is registered. | 105 // Can't wait for sync token before client is registered. |
107 EXPECT_TRUE(sync_point_manager_->IsSyncTokenReleased(sync_token)); | 106 EXPECT_TRUE(sync_point_manager_->IsSyncTokenReleased(sync_token)); |
108 | 107 |
109 SyncPointStream stream(sync_point_manager_.get(), kNamespaceId, kBufferId); | 108 SyncPointStream stream(sync_point_manager_.get(), kNamespaceId, kBufferId); |
110 | 109 |
111 stream.AllocateOrderNum(sync_point_manager_.get()); | 110 stream.AllocateOrderNum(); |
112 | 111 |
113 EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token)); | 112 EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token)); |
114 | 113 |
115 stream.order_data->BeginProcessingOrderNumber(1); | 114 stream.order_data->BeginProcessingOrderNumber(1); |
116 stream.client->ReleaseFenceSync(release_count); | 115 stream.client_state->ReleaseFenceSync(release_count); |
117 stream.order_data->FinishProcessingOrderNumber(1); | 116 stream.order_data->FinishProcessingOrderNumber(1); |
118 | 117 |
119 EXPECT_TRUE(sync_point_manager_->IsSyncTokenReleased(sync_token)); | 118 EXPECT_TRUE(sync_point_manager_->IsSyncTokenReleased(sync_token)); |
120 } | 119 } |
121 | 120 |
122 TEST_F(SyncPointManagerTest, MultipleClientsPerOrderData) { | 121 TEST_F(SyncPointManagerTest, MultipleClientsPerOrderData) { |
123 CommandBufferNamespace kNamespaceId = gpu::CommandBufferNamespace::GPU_IO; | 122 CommandBufferNamespace kNamespaceId = gpu::CommandBufferNamespace::GPU_IO; |
124 CommandBufferId kCmdBufferId1 = CommandBufferId::FromUnsafeValue(0x123); | 123 CommandBufferId kCmdBufferId1 = CommandBufferId::FromUnsafeValue(0x123); |
125 CommandBufferId kCmdBufferId2 = CommandBufferId::FromUnsafeValue(0x234); | 124 CommandBufferId kCmdBufferId2 = CommandBufferId::FromUnsafeValue(0x234); |
126 | 125 |
127 SyncPointStream stream1(sync_point_manager_.get(), kNamespaceId, | 126 SyncPointStream stream1(sync_point_manager_.get(), kNamespaceId, |
128 kCmdBufferId1); | 127 kCmdBufferId1); |
129 SyncPointStream stream2(sync_point_manager_.get(), kNamespaceId, | 128 SyncPointStream stream2(sync_point_manager_.get(), kNamespaceId, |
130 kCmdBufferId2); | 129 kCmdBufferId2); |
131 | 130 |
132 uint64_t release_count = 1; | 131 uint64_t release_count = 1; |
133 SyncToken sync_token1(kNamespaceId, 0, kCmdBufferId1, release_count); | 132 SyncToken sync_token1(kNamespaceId, 0, kCmdBufferId1, release_count); |
134 stream1.AllocateOrderNum(sync_point_manager_.get()); | 133 stream1.AllocateOrderNum(); |
135 | 134 |
136 SyncToken sync_token2(kNamespaceId, 0, kCmdBufferId2, release_count); | 135 SyncToken sync_token2(kNamespaceId, 0, kCmdBufferId2, release_count); |
137 stream2.AllocateOrderNum(sync_point_manager_.get()); | 136 stream2.AllocateOrderNum(); |
138 | 137 |
139 EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token1)); | 138 EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token1)); |
140 EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token2)); | 139 EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token2)); |
141 | 140 |
142 stream1.order_data->BeginProcessingOrderNumber(1); | 141 stream1.order_data->BeginProcessingOrderNumber(1); |
143 stream1.client->ReleaseFenceSync(release_count); | 142 stream1.client_state->ReleaseFenceSync(release_count); |
144 stream1.order_data->FinishProcessingOrderNumber(1); | 143 stream1.order_data->FinishProcessingOrderNumber(1); |
145 | 144 |
146 EXPECT_TRUE(sync_point_manager_->IsSyncTokenReleased(sync_token1)); | 145 EXPECT_TRUE(sync_point_manager_->IsSyncTokenReleased(sync_token1)); |
147 EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token2)); | 146 EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token2)); |
148 } | 147 } |
149 | 148 |
150 TEST_F(SyncPointManagerTest, BasicFenceSyncWaitRelease) { | 149 TEST_F(SyncPointManagerTest, BasicFenceSyncWaitRelease) { |
151 CommandBufferNamespace kNamespaceId = gpu::CommandBufferNamespace::GPU_IO; | 150 CommandBufferNamespace kNamespaceId = gpu::CommandBufferNamespace::GPU_IO; |
152 CommandBufferId kReleaseCmdBufferId = CommandBufferId::FromUnsafeValue(0x123); | 151 CommandBufferId kReleaseCmdBufferId = CommandBufferId::FromUnsafeValue(0x123); |
153 CommandBufferId kWaitCmdBufferId = CommandBufferId::FromUnsafeValue(0x234); | 152 CommandBufferId kWaitCmdBufferId = CommandBufferId::FromUnsafeValue(0x234); |
154 | 153 |
155 SyncPointStream release_stream(sync_point_manager_.get(), kNamespaceId, | 154 SyncPointStream release_stream(sync_point_manager_.get(), kNamespaceId, |
156 kReleaseCmdBufferId); | 155 kReleaseCmdBufferId); |
157 SyncPointStream wait_stream(sync_point_manager_.get(), kNamespaceId, | 156 SyncPointStream wait_stream(sync_point_manager_.get(), kNamespaceId, |
158 kWaitCmdBufferId); | 157 kWaitCmdBufferId); |
159 | 158 |
160 release_stream.AllocateOrderNum(sync_point_manager_.get()); | 159 release_stream.AllocateOrderNum(); |
161 wait_stream.AllocateOrderNum(sync_point_manager_.get()); | 160 wait_stream.AllocateOrderNum(); |
162 | 161 |
163 uint64_t release_count = 1; | 162 uint64_t release_count = 1; |
164 SyncToken sync_token(kNamespaceId, 0, kReleaseCmdBufferId, release_count); | 163 SyncToken sync_token(kNamespaceId, 0, kReleaseCmdBufferId, release_count); |
165 | 164 |
166 wait_stream.BeginProcessing(); | 165 wait_stream.BeginProcessing(); |
167 int test_num = 10; | 166 int test_num = 10; |
168 bool valid_wait = wait_stream.client->Wait( | 167 bool valid_wait = wait_stream.client_state->Wait( |
169 sync_token, | 168 sync_token, |
170 base::Bind(&SyncPointManagerTest::SetIntegerFunction, &test_num, 123)); | 169 base::Bind(&SyncPointManagerTest::SetIntegerFunction, &test_num, 123)); |
171 EXPECT_TRUE(valid_wait); | 170 EXPECT_TRUE(valid_wait); |
172 EXPECT_EQ(10, test_num); | 171 EXPECT_EQ(10, test_num); |
173 EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token)); | 172 EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token)); |
174 | 173 |
175 release_stream.BeginProcessing(); | 174 release_stream.BeginProcessing(); |
176 release_stream.client->ReleaseFenceSync(release_count); | 175 release_stream.client_state->ReleaseFenceSync(release_count); |
177 EXPECT_EQ(123, test_num); | 176 EXPECT_EQ(123, test_num); |
178 EXPECT_TRUE(sync_point_manager_->IsSyncTokenReleased(sync_token)); | 177 EXPECT_TRUE(sync_point_manager_->IsSyncTokenReleased(sync_token)); |
179 } | 178 } |
180 | 179 |
181 TEST_F(SyncPointManagerTest, WaitOnSelfFails) { | 180 TEST_F(SyncPointManagerTest, WaitOnSelfFails) { |
182 CommandBufferNamespace kNamespaceId = gpu::CommandBufferNamespace::GPU_IO; | 181 CommandBufferNamespace kNamespaceId = gpu::CommandBufferNamespace::GPU_IO; |
183 CommandBufferId kReleaseCmdBufferId = CommandBufferId::FromUnsafeValue(0x123); | 182 CommandBufferId kReleaseCmdBufferId = CommandBufferId::FromUnsafeValue(0x123); |
184 CommandBufferId kWaitCmdBufferId = CommandBufferId::FromUnsafeValue(0x234); | 183 CommandBufferId kWaitCmdBufferId = CommandBufferId::FromUnsafeValue(0x234); |
185 | 184 |
186 SyncPointStream release_stream(sync_point_manager_.get(), kNamespaceId, | 185 SyncPointStream release_stream(sync_point_manager_.get(), kNamespaceId, |
187 kReleaseCmdBufferId); | 186 kReleaseCmdBufferId); |
188 SyncPointStream wait_stream(sync_point_manager_.get(), kNamespaceId, | 187 SyncPointStream wait_stream(sync_point_manager_.get(), kNamespaceId, |
189 kWaitCmdBufferId); | 188 kWaitCmdBufferId); |
190 | 189 |
191 release_stream.AllocateOrderNum(sync_point_manager_.get()); | 190 release_stream.AllocateOrderNum(); |
192 wait_stream.AllocateOrderNum(sync_point_manager_.get()); | 191 wait_stream.AllocateOrderNum(); |
193 | 192 |
194 uint64_t release_count = 1; | 193 uint64_t release_count = 1; |
195 SyncToken sync_token(kNamespaceId, 0, kWaitCmdBufferId, release_count); | 194 SyncToken sync_token(kNamespaceId, 0, kWaitCmdBufferId, release_count); |
196 | 195 |
197 wait_stream.BeginProcessing(); | 196 wait_stream.BeginProcessing(); |
198 int test_num = 10; | 197 int test_num = 10; |
199 bool valid_wait = wait_stream.client->Wait( | 198 bool valid_wait = wait_stream.client_state->Wait( |
200 sync_token, | 199 sync_token, |
201 base::Bind(&SyncPointManagerTest::SetIntegerFunction, &test_num, 123)); | 200 base::Bind(&SyncPointManagerTest::SetIntegerFunction, &test_num, 123)); |
202 EXPECT_FALSE(valid_wait); | 201 EXPECT_FALSE(valid_wait); |
203 EXPECT_EQ(10, test_num); | 202 EXPECT_EQ(10, test_num); |
204 EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token)); | 203 EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token)); |
205 } | 204 } |
206 | 205 |
207 TEST_F(SyncPointManagerTest, OutOfOrderRelease) { | 206 TEST_F(SyncPointManagerTest, OutOfOrderRelease) { |
208 CommandBufferNamespace kNamespaceId = gpu::CommandBufferNamespace::GPU_IO; | 207 CommandBufferNamespace kNamespaceId = gpu::CommandBufferNamespace::GPU_IO; |
209 CommandBufferId kReleaseCmdBufferId = CommandBufferId::FromUnsafeValue(0x123); | 208 CommandBufferId kReleaseCmdBufferId = CommandBufferId::FromUnsafeValue(0x123); |
210 CommandBufferId kWaitCmdBufferId = CommandBufferId::FromUnsafeValue(0x234); | 209 CommandBufferId kWaitCmdBufferId = CommandBufferId::FromUnsafeValue(0x234); |
211 | 210 |
212 SyncPointStream release_stream(sync_point_manager_.get(), kNamespaceId, | 211 SyncPointStream release_stream(sync_point_manager_.get(), kNamespaceId, |
213 kReleaseCmdBufferId); | 212 kReleaseCmdBufferId); |
214 SyncPointStream wait_stream(sync_point_manager_.get(), kNamespaceId, | 213 SyncPointStream wait_stream(sync_point_manager_.get(), kNamespaceId, |
215 kWaitCmdBufferId); | 214 kWaitCmdBufferId); |
216 | 215 |
217 // Generate wait order number first. | 216 // Generate wait order number first. |
218 wait_stream.AllocateOrderNum(sync_point_manager_.get()); | 217 wait_stream.AllocateOrderNum(); |
219 release_stream.AllocateOrderNum(sync_point_manager_.get()); | 218 release_stream.AllocateOrderNum(); |
220 | 219 |
221 uint64_t release_count = 1; | 220 uint64_t release_count = 1; |
222 SyncToken sync_token(kNamespaceId, 0, kReleaseCmdBufferId, release_count); | 221 SyncToken sync_token(kNamespaceId, 0, kReleaseCmdBufferId, release_count); |
223 | 222 |
224 wait_stream.BeginProcessing(); | 223 wait_stream.BeginProcessing(); |
225 int test_num = 10; | 224 int test_num = 10; |
226 bool valid_wait = wait_stream.client->Wait( | 225 bool valid_wait = wait_stream.client_state->Wait( |
227 sync_token, | 226 sync_token, |
228 base::Bind(&SyncPointManagerTest::SetIntegerFunction, &test_num, 123)); | 227 base::Bind(&SyncPointManagerTest::SetIntegerFunction, &test_num, 123)); |
229 EXPECT_FALSE(valid_wait); | 228 EXPECT_FALSE(valid_wait); |
230 EXPECT_EQ(10, test_num); | 229 EXPECT_EQ(10, test_num); |
231 EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token)); | 230 EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token)); |
232 } | 231 } |
233 | 232 |
234 TEST_F(SyncPointManagerTest, HigherOrderNumberRelease) { | 233 TEST_F(SyncPointManagerTest, HigherOrderNumberRelease) { |
235 CommandBufferNamespace kNamespaceId = gpu::CommandBufferNamespace::GPU_IO; | 234 CommandBufferNamespace kNamespaceId = gpu::CommandBufferNamespace::GPU_IO; |
236 CommandBufferId kReleaseCmdBufferId = CommandBufferId::FromUnsafeValue(0x123); | 235 CommandBufferId kReleaseCmdBufferId = CommandBufferId::FromUnsafeValue(0x123); |
237 CommandBufferId kWaitCmdBufferId = CommandBufferId::FromUnsafeValue(0x234); | 236 CommandBufferId kWaitCmdBufferId = CommandBufferId::FromUnsafeValue(0x234); |
238 | 237 |
239 SyncPointStream release_stream(sync_point_manager_.get(), kNamespaceId, | 238 SyncPointStream release_stream(sync_point_manager_.get(), kNamespaceId, |
240 kReleaseCmdBufferId); | 239 kReleaseCmdBufferId); |
241 SyncPointStream wait_stream(sync_point_manager_.get(), kNamespaceId, | 240 SyncPointStream wait_stream(sync_point_manager_.get(), kNamespaceId, |
242 kWaitCmdBufferId); | 241 kWaitCmdBufferId); |
243 | 242 |
244 // Generate wait order number first. | 243 // Generate wait order number first. |
245 wait_stream.AllocateOrderNum(sync_point_manager_.get()); | 244 wait_stream.AllocateOrderNum(); |
246 release_stream.AllocateOrderNum(sync_point_manager_.get()); | 245 release_stream.AllocateOrderNum(); |
247 | 246 |
248 uint64_t release_count = 1; | 247 uint64_t release_count = 1; |
249 SyncToken sync_token(kNamespaceId, 0, kReleaseCmdBufferId, release_count); | 248 SyncToken sync_token(kNamespaceId, 0, kReleaseCmdBufferId, release_count); |
250 | 249 |
251 // Order number was higher but it was actually released. | 250 // Order number was higher but it was actually released. |
252 release_stream.BeginProcessing(); | 251 release_stream.BeginProcessing(); |
253 release_stream.client->ReleaseFenceSync(release_count); | 252 release_stream.client_state->ReleaseFenceSync(release_count); |
254 release_stream.EndProcessing(); | 253 release_stream.EndProcessing(); |
255 | 254 |
256 // Release stream has already released so there's no need to wait. | 255 // Release stream has already released so there's no need to wait. |
257 wait_stream.BeginProcessing(); | 256 wait_stream.BeginProcessing(); |
258 int test_num = 10; | 257 int test_num = 10; |
259 bool valid_wait = wait_stream.client->Wait( | 258 bool valid_wait = wait_stream.client_state->Wait( |
260 sync_token, | 259 sync_token, |
261 base::Bind(&SyncPointManagerTest::SetIntegerFunction, &test_num, 123)); | 260 base::Bind(&SyncPointManagerTest::SetIntegerFunction, &test_num, 123)); |
262 EXPECT_FALSE(valid_wait); | 261 EXPECT_FALSE(valid_wait); |
263 EXPECT_EQ(10, test_num); | 262 EXPECT_EQ(10, test_num); |
264 EXPECT_TRUE(sync_point_manager_->IsSyncTokenReleased(sync_token)); | 263 EXPECT_TRUE(sync_point_manager_->IsSyncTokenReleased(sync_token)); |
265 } | 264 } |
266 | 265 |
267 TEST_F(SyncPointManagerTest, DestroyedClientRelease) { | 266 TEST_F(SyncPointManagerTest, DestroyedClientRelease) { |
268 CommandBufferNamespace kNamespaceId = gpu::CommandBufferNamespace::GPU_IO; | 267 CommandBufferNamespace kNamespaceId = gpu::CommandBufferNamespace::GPU_IO; |
269 CommandBufferId kReleaseCmdBufferId = CommandBufferId::FromUnsafeValue(0x123); | 268 CommandBufferId kReleaseCmdBufferId = CommandBufferId::FromUnsafeValue(0x123); |
270 CommandBufferId kWaitCmdBufferId = CommandBufferId::FromUnsafeValue(0x234); | 269 CommandBufferId kWaitCmdBufferId = CommandBufferId::FromUnsafeValue(0x234); |
271 | 270 |
272 SyncPointStream release_stream(sync_point_manager_.get(), kNamespaceId, | 271 SyncPointStream release_stream(sync_point_manager_.get(), kNamespaceId, |
273 kReleaseCmdBufferId); | 272 kReleaseCmdBufferId); |
274 SyncPointStream wait_stream(sync_point_manager_.get(), kNamespaceId, | 273 SyncPointStream wait_stream(sync_point_manager_.get(), kNamespaceId, |
275 kWaitCmdBufferId); | 274 kWaitCmdBufferId); |
276 | 275 |
277 release_stream.AllocateOrderNum(sync_point_manager_.get()); | 276 release_stream.AllocateOrderNum(); |
278 wait_stream.AllocateOrderNum(sync_point_manager_.get()); | 277 wait_stream.AllocateOrderNum(); |
279 | 278 |
280 uint64_t release_count = 1; | 279 uint64_t release_count = 1; |
281 SyncToken sync_token(kNamespaceId, 0, kReleaseCmdBufferId, release_count); | 280 SyncToken sync_token(kNamespaceId, 0, kReleaseCmdBufferId, release_count); |
282 | 281 |
283 wait_stream.BeginProcessing(); | 282 wait_stream.BeginProcessing(); |
284 | 283 |
285 int test_num = 10; | 284 int test_num = 10; |
286 bool valid_wait = wait_stream.client->Wait( | 285 bool valid_wait = wait_stream.client_state->Wait( |
287 sync_token, | 286 sync_token, |
288 base::Bind(&SyncPointManagerTest::SetIntegerFunction, &test_num, 123)); | 287 base::Bind(&SyncPointManagerTest::SetIntegerFunction, &test_num, 123)); |
289 EXPECT_TRUE(valid_wait); | 288 EXPECT_TRUE(valid_wait); |
290 EXPECT_EQ(10, test_num); | 289 EXPECT_EQ(10, test_num); |
291 | 290 |
292 // Destroying the client should release the wait. | 291 // Destroying the client should release the wait. |
293 release_stream.client.reset(); | 292 release_stream.client_state->Destroy(); |
| 293 |
294 EXPECT_EQ(123, test_num); | 294 EXPECT_EQ(123, test_num); |
295 EXPECT_TRUE(sync_point_manager_->IsSyncTokenReleased(sync_token)); | 295 EXPECT_TRUE(sync_point_manager_->IsSyncTokenReleased(sync_token)); |
296 } | 296 } |
297 | 297 |
298 TEST_F(SyncPointManagerTest, NonExistentRelease) { | 298 TEST_F(SyncPointManagerTest, NonExistentRelease) { |
299 CommandBufferNamespace kNamespaceId = gpu::CommandBufferNamespace::GPU_IO; | 299 CommandBufferNamespace kNamespaceId = gpu::CommandBufferNamespace::GPU_IO; |
300 CommandBufferId kReleaseCmdBufferId = CommandBufferId::FromUnsafeValue(0x123); | 300 CommandBufferId kReleaseCmdBufferId = CommandBufferId::FromUnsafeValue(0x123); |
301 CommandBufferId kWaitCmdBufferId = CommandBufferId::FromUnsafeValue(0x234); | 301 CommandBufferId kWaitCmdBufferId = CommandBufferId::FromUnsafeValue(0x234); |
302 | 302 |
303 SyncPointStream release_stream(sync_point_manager_.get(), kNamespaceId, | 303 SyncPointStream release_stream(sync_point_manager_.get(), kNamespaceId, |
304 kReleaseCmdBufferId); | 304 kReleaseCmdBufferId); |
305 SyncPointStream wait_stream(sync_point_manager_.get(), kNamespaceId, | 305 SyncPointStream wait_stream(sync_point_manager_.get(), kNamespaceId, |
306 kWaitCmdBufferId); | 306 kWaitCmdBufferId); |
307 | 307 |
308 // Assign release stream order [1] and wait stream order [2]. | 308 // Assign release stream order [1] and wait stream order [2]. |
309 // This test simply tests that a wait stream of order [2] waiting on | 309 // This test simply tests that a wait stream of order [2] waiting on |
310 // release stream of order [1] will still release the fence sync even | 310 // release stream of order [1] will still release the fence sync even |
311 // though nothing was released. | 311 // though nothing was released. |
312 release_stream.AllocateOrderNum(sync_point_manager_.get()); | 312 release_stream.AllocateOrderNum(); |
313 wait_stream.AllocateOrderNum(sync_point_manager_.get()); | 313 wait_stream.AllocateOrderNum(); |
314 | 314 |
315 uint64_t release_count = 1; | 315 uint64_t release_count = 1; |
316 SyncToken sync_token(kNamespaceId, 0, kReleaseCmdBufferId, release_count); | 316 SyncToken sync_token(kNamespaceId, 0, kReleaseCmdBufferId, release_count); |
317 | 317 |
318 wait_stream.BeginProcessing(); | 318 wait_stream.BeginProcessing(); |
319 int test_num = 10; | 319 int test_num = 10; |
320 bool valid_wait = wait_stream.client->Wait( | 320 bool valid_wait = wait_stream.client_state->Wait( |
321 sync_token, | 321 sync_token, |
322 base::Bind(&SyncPointManagerTest::SetIntegerFunction, &test_num, 123)); | 322 base::Bind(&SyncPointManagerTest::SetIntegerFunction, &test_num, 123)); |
323 EXPECT_TRUE(valid_wait); | 323 EXPECT_TRUE(valid_wait); |
324 EXPECT_EQ(10, test_num); | 324 EXPECT_EQ(10, test_num); |
325 EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token)); | 325 EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token)); |
326 | 326 |
327 // No release but finishing the order number should automatically release. | 327 // No release but finishing the order number should automatically release. |
328 release_stream.BeginProcessing(); | 328 release_stream.BeginProcessing(); |
329 EXPECT_EQ(10, test_num); | 329 EXPECT_EQ(10, test_num); |
330 release_stream.EndProcessing(); | 330 release_stream.EndProcessing(); |
(...skipping 10 matching lines...) Expand all Loading... |
341 kReleaseCmdBufferId); | 341 kReleaseCmdBufferId); |
342 SyncPointStream wait_stream(sync_point_manager_.get(), kNamespaceId, | 342 SyncPointStream wait_stream(sync_point_manager_.get(), kNamespaceId, |
343 kWaitCmdBufferId); | 343 kWaitCmdBufferId); |
344 | 344 |
345 // Assign Release stream order [1] and assign Wait stream orders [2, 3]. | 345 // Assign Release stream order [1] and assign Wait stream orders [2, 3]. |
346 // This test is similar to the NonExistentRelease case except | 346 // This test is similar to the NonExistentRelease case except |
347 // we place an extra order number in between the release and wait. | 347 // we place an extra order number in between the release and wait. |
348 // The wait stream [3] is waiting on release stream [1] even though | 348 // The wait stream [3] is waiting on release stream [1] even though |
349 // order [2] was also generated. Although order [2] only exists on the | 349 // order [2] was also generated. Although order [2] only exists on the |
350 // wait stream so the release stream should only know about order [1]. | 350 // wait stream so the release stream should only know about order [1]. |
351 release_stream.AllocateOrderNum(sync_point_manager_.get()); | 351 release_stream.AllocateOrderNum(); |
352 wait_stream.AllocateOrderNum(sync_point_manager_.get()); | 352 wait_stream.AllocateOrderNum(); |
353 wait_stream.AllocateOrderNum(sync_point_manager_.get()); | 353 wait_stream.AllocateOrderNum(); |
354 | 354 |
355 uint64_t release_count = 1; | 355 uint64_t release_count = 1; |
356 SyncToken sync_token(kNamespaceId, 0, kReleaseCmdBufferId, release_count); | 356 SyncToken sync_token(kNamespaceId, 0, kReleaseCmdBufferId, release_count); |
357 | 357 |
358 EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token)); | 358 EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token)); |
359 // Have wait with order [3] to wait on release. | 359 // Have wait with order [3] to wait on release. |
360 wait_stream.BeginProcessing(); | 360 wait_stream.BeginProcessing(); |
361 EXPECT_EQ(2u, wait_stream.order_data->current_order_num()); | 361 EXPECT_EQ(2u, wait_stream.order_data->current_order_num()); |
362 wait_stream.EndProcessing(); | 362 wait_stream.EndProcessing(); |
363 wait_stream.BeginProcessing(); | 363 wait_stream.BeginProcessing(); |
364 EXPECT_EQ(3u, wait_stream.order_data->current_order_num()); | 364 EXPECT_EQ(3u, wait_stream.order_data->current_order_num()); |
365 int test_num = 10; | 365 int test_num = 10; |
366 bool valid_wait = wait_stream.client->Wait( | 366 bool valid_wait = wait_stream.client_state->Wait( |
367 sync_token, | 367 sync_token, |
368 base::Bind(&SyncPointManagerTest::SetIntegerFunction, &test_num, 123)); | 368 base::Bind(&SyncPointManagerTest::SetIntegerFunction, &test_num, 123)); |
369 EXPECT_TRUE(valid_wait); | 369 EXPECT_TRUE(valid_wait); |
370 EXPECT_EQ(10, test_num); | 370 EXPECT_EQ(10, test_num); |
371 EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token)); | 371 EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token)); |
372 | 372 |
373 // Even though release stream order [1] did not have a release, it | 373 // Even though release stream order [1] did not have a release, it |
374 // should have changed test_num although the fence sync is still not released. | 374 // should have changed test_num although the fence sync is still not released. |
375 release_stream.BeginProcessing(); | 375 release_stream.BeginProcessing(); |
376 EXPECT_EQ(1u, release_stream.order_data->current_order_num()); | 376 EXPECT_EQ(1u, release_stream.order_data->current_order_num()); |
377 release_stream.EndProcessing(); | 377 release_stream.EndProcessing(); |
378 EXPECT_EQ(123, test_num); | 378 EXPECT_EQ(123, test_num); |
379 EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token)); | 379 EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token)); |
380 | 380 |
381 // Ensure that the wait callback does not get triggered again when it is | 381 // Ensure that the wait callback does not get triggered again when it is |
382 // actually released. | 382 // actually released. |
383 test_num = 1; | 383 test_num = 1; |
384 release_stream.AllocateOrderNum(sync_point_manager_.get()); | 384 release_stream.AllocateOrderNum(); |
385 release_stream.BeginProcessing(); | 385 release_stream.BeginProcessing(); |
386 release_stream.client->ReleaseFenceSync(release_count); | 386 release_stream.client_state->ReleaseFenceSync(release_count); |
387 release_stream.EndProcessing(); | 387 release_stream.EndProcessing(); |
388 EXPECT_EQ(1, test_num); | 388 EXPECT_EQ(1, test_num); |
389 EXPECT_TRUE(sync_point_manager_->IsSyncTokenReleased(sync_token)); | 389 EXPECT_TRUE(sync_point_manager_->IsSyncTokenReleased(sync_token)); |
390 } | 390 } |
391 | 391 |
392 TEST_F(SyncPointManagerTest, NonExistentOrderNumRelease) { | 392 TEST_F(SyncPointManagerTest, NonExistentOrderNumRelease) { |
393 CommandBufferNamespace kNamespaceId = gpu::CommandBufferNamespace::GPU_IO; | 393 CommandBufferNamespace kNamespaceId = gpu::CommandBufferNamespace::GPU_IO; |
394 CommandBufferId kReleaseCmdBufferId = CommandBufferId::FromUnsafeValue(0x123); | 394 CommandBufferId kReleaseCmdBufferId = CommandBufferId::FromUnsafeValue(0x123); |
395 CommandBufferId kWaitCmdBufferId = CommandBufferId::FromUnsafeValue(0x234); | 395 CommandBufferId kWaitCmdBufferId = CommandBufferId::FromUnsafeValue(0x234); |
396 | 396 |
397 SyncPointStream release_stream(sync_point_manager_.get(), kNamespaceId, | 397 SyncPointStream release_stream(sync_point_manager_.get(), kNamespaceId, |
398 kReleaseCmdBufferId); | 398 kReleaseCmdBufferId); |
399 SyncPointStream wait_stream(sync_point_manager_.get(), kNamespaceId, | 399 SyncPointStream wait_stream(sync_point_manager_.get(), kNamespaceId, |
400 kWaitCmdBufferId); | 400 kWaitCmdBufferId); |
401 | 401 |
402 // Assign Release stream orders [1, 4] and assign Wait stream orders [2, 3]. | 402 // Assign Release stream orders [1, 4] and assign Wait stream orders [2, 3]. |
403 // Here we are testing that wait order [3] will wait on a fence sync | 403 // Here we are testing that wait order [3] will wait on a fence sync |
404 // in either order [1] or order [2]. Order [2] was not actually assigned | 404 // in either order [1] or order [2]. Order [2] was not actually assigned |
405 // to the release stream so it is essentially non-existent to the release | 405 // to the release stream so it is essentially non-existent to the release |
406 // stream's point of view. Once the release stream begins processing the next | 406 // stream's point of view. Once the release stream begins processing the next |
407 // order [3], it should realize order [2] didn't exist and release the fence. | 407 // order [3], it should realize order [2] didn't exist and release the fence. |
408 release_stream.AllocateOrderNum(sync_point_manager_.get()); | 408 release_stream.AllocateOrderNum(); |
409 wait_stream.AllocateOrderNum(sync_point_manager_.get()); | 409 wait_stream.AllocateOrderNum(); |
410 wait_stream.AllocateOrderNum(sync_point_manager_.get()); | 410 wait_stream.AllocateOrderNum(); |
411 release_stream.AllocateOrderNum(sync_point_manager_.get()); | 411 release_stream.AllocateOrderNum(); |
412 | 412 |
413 uint64_t release_count = 1; | 413 uint64_t release_count = 1; |
414 SyncToken sync_token(kNamespaceId, 0, kReleaseCmdBufferId, release_count); | 414 SyncToken sync_token(kNamespaceId, 0, kReleaseCmdBufferId, release_count); |
415 | 415 |
416 // Have wait with order [3] to wait on release order [1] or [2]. | 416 // Have wait with order [3] to wait on release order [1] or [2]. |
417 wait_stream.BeginProcessing(); | 417 wait_stream.BeginProcessing(); |
418 EXPECT_EQ(2u, wait_stream.order_data->current_order_num()); | 418 EXPECT_EQ(2u, wait_stream.order_data->current_order_num()); |
419 wait_stream.EndProcessing(); | 419 wait_stream.EndProcessing(); |
420 wait_stream.BeginProcessing(); | 420 wait_stream.BeginProcessing(); |
421 EXPECT_EQ(3u, wait_stream.order_data->current_order_num()); | 421 EXPECT_EQ(3u, wait_stream.order_data->current_order_num()); |
422 int test_num = 10; | 422 int test_num = 10; |
423 bool valid_wait = wait_stream.client->Wait( | 423 bool valid_wait = wait_stream.client_state->Wait( |
424 sync_token, | 424 sync_token, |
425 base::Bind(&SyncPointManagerTest::SetIntegerFunction, &test_num, 123)); | 425 base::Bind(&SyncPointManagerTest::SetIntegerFunction, &test_num, 123)); |
426 EXPECT_TRUE(valid_wait); | 426 EXPECT_TRUE(valid_wait); |
427 EXPECT_EQ(10, test_num); | 427 EXPECT_EQ(10, test_num); |
428 | 428 |
429 // Release stream should know it should release fence sync by order [3], | 429 // Release stream should know it should release fence sync by order [3], |
430 // so going through order [1] should not release it yet. | 430 // so going through order [1] should not release it yet. |
431 release_stream.BeginProcessing(); | 431 release_stream.BeginProcessing(); |
432 EXPECT_EQ(1u, release_stream.order_data->current_order_num()); | 432 EXPECT_EQ(1u, release_stream.order_data->current_order_num()); |
433 release_stream.EndProcessing(); | 433 release_stream.EndProcessing(); |
434 EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token)); | 434 EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token)); |
435 EXPECT_EQ(10, test_num); | 435 EXPECT_EQ(10, test_num); |
436 | 436 |
437 // Beginning order [4] should immediately trigger the wait although the fence | 437 // Beginning order [4] should immediately trigger the wait although the fence |
438 // sync is still not released yet. | 438 // sync is still not released yet. |
439 release_stream.BeginProcessing(); | 439 release_stream.BeginProcessing(); |
440 EXPECT_EQ(4u, release_stream.order_data->current_order_num()); | 440 EXPECT_EQ(4u, release_stream.order_data->current_order_num()); |
441 EXPECT_EQ(123, test_num); | 441 EXPECT_EQ(123, test_num); |
442 EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token)); | 442 EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token)); |
443 | 443 |
444 // Ensure that the wait callback does not get triggered again when it is | 444 // Ensure that the wait callback does not get triggered again when it is |
445 // actually released. | 445 // actually released. |
446 test_num = 1; | 446 test_num = 1; |
447 release_stream.client->ReleaseFenceSync(1); | 447 release_stream.client_state->ReleaseFenceSync(1); |
448 EXPECT_EQ(1, test_num); | 448 EXPECT_EQ(1, test_num); |
449 EXPECT_TRUE(sync_point_manager_->IsSyncTokenReleased(sync_token)); | 449 EXPECT_TRUE(sync_point_manager_->IsSyncTokenReleased(sync_token)); |
450 } | 450 } |
451 | 451 |
452 } // namespace gpu | 452 } // namespace gpu |
OLD | NEW |