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