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