OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 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 "cc/raster/tile_task_worker_pool.h" | 5 #include "cc/raster/tile_task_worker_pool.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 #include <stdint.h> | 8 #include <stdint.h> |
9 | 9 |
10 #include "base/macros.h" | 10 #include "base/macros.h" |
11 #include "base/test/test_simple_task_runner.h" | 11 #include "base/test/test_simple_task_runner.h" |
12 #include "base/time/time.h" | 12 #include "base/time/time.h" |
13 #include "cc/debug/lap_timer.h" | 13 #include "cc/debug/lap_timer.h" |
14 #include "cc/output/context_provider.h" | 14 #include "cc/output/context_provider.h" |
15 #include "cc/raster/bitmap_tile_task_worker_pool.h" | 15 #include "cc/raster/bitmap_tile_task_worker_pool.h" |
16 #include "cc/raster/gpu_rasterizer.h" | 16 #include "cc/raster/gpu_rasterizer.h" |
17 #include "cc/raster/gpu_tile_task_worker_pool.h" | 17 #include "cc/raster/gpu_tile_task_worker_pool.h" |
18 #include "cc/raster/one_copy_tile_task_worker_pool.h" | 18 #include "cc/raster/one_copy_tile_task_worker_pool.h" |
19 #include "cc/raster/raster_buffer.h" | |
20 #include "cc/raster/synchronous_task_graph_runner.h" | 19 #include "cc/raster/synchronous_task_graph_runner.h" |
21 #include "cc/raster/tile_task_runner.h" | 20 #include "cc/raster/tile_task_runner.h" |
22 #include "cc/raster/zero_copy_tile_task_worker_pool.h" | 21 #include "cc/raster/zero_copy_tile_task_worker_pool.h" |
23 #include "cc/resources/resource_pool.h" | 22 #include "cc/resources/resource_pool.h" |
24 #include "cc/resources/resource_provider.h" | 23 #include "cc/resources/resource_provider.h" |
25 #include "cc/resources/scoped_resource.h" | 24 #include "cc/resources/scoped_resource.h" |
26 #include "cc/test/fake_output_surface.h" | 25 #include "cc/test/fake_output_surface.h" |
27 #include "cc/test/fake_output_surface_client.h" | 26 #include "cc/test/fake_output_surface_client.h" |
28 #include "cc/test/fake_resource_provider.h" | 27 #include "cc/test/fake_resource_provider.h" |
29 #include "cc/test/test_context_support.h" | 28 #include "cc/test/test_context_support.h" |
(...skipping 87 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
117 TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY, | 116 TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY, |
118 TILE_TASK_WORKER_POOL_TYPE_ONE_COPY, | 117 TILE_TASK_WORKER_POOL_TYPE_ONE_COPY, |
119 TILE_TASK_WORKER_POOL_TYPE_GPU, | 118 TILE_TASK_WORKER_POOL_TYPE_GPU, |
120 TILE_TASK_WORKER_POOL_TYPE_BITMAP | 119 TILE_TASK_WORKER_POOL_TYPE_BITMAP |
121 }; | 120 }; |
122 | 121 |
123 static const int kTimeLimitMillis = 2000; | 122 static const int kTimeLimitMillis = 2000; |
124 static const int kWarmupRuns = 5; | 123 static const int kWarmupRuns = 5; |
125 static const int kTimeCheckInterval = 10; | 124 static const int kTimeCheckInterval = 10; |
126 | 125 |
127 class PerfImageDecodeTaskImpl : public ImageDecodeTask { | 126 class PerfImageDecodeTaskImpl : public Task { |
128 public: | 127 public: |
129 PerfImageDecodeTaskImpl() {} | 128 PerfImageDecodeTaskImpl() {} |
130 | 129 |
131 // Overridden from Task: | 130 // Overridden from Task: |
| 131 void ScheduleOnOriginThread() override {} |
| 132 void CompleteOnOriginThread() override { Reset(); } |
132 void RunOnWorkerThread() override {} | 133 void RunOnWorkerThread() override {} |
133 | 134 |
134 // Overridden from TileTask: | |
135 void ScheduleOnOriginThread(TileTaskClient* client) override {} | |
136 void CompleteOnOriginThread(TileTaskClient* client) override { Reset(); } | |
137 | |
138 void Reset() { | 135 void Reset() { |
139 did_run_ = false; | 136 did_run_ = false; |
140 did_complete_ = false; | 137 did_complete_ = false; |
141 } | 138 } |
142 | 139 |
143 protected: | 140 protected: |
144 ~PerfImageDecodeTaskImpl() override {} | 141 ~PerfImageDecodeTaskImpl() override {} |
145 | 142 |
146 private: | 143 private: |
147 DISALLOW_COPY_AND_ASSIGN(PerfImageDecodeTaskImpl); | 144 DISALLOW_COPY_AND_ASSIGN(PerfImageDecodeTaskImpl); |
148 }; | 145 }; |
149 | 146 |
150 class PerfRasterTaskImpl : public RasterTask { | 147 class PerfRasterTaskImpl : public Task { |
151 public: | 148 public: |
152 PerfRasterTaskImpl(scoped_ptr<ScopedResource> resource, | 149 PerfRasterTaskImpl(RasterBufferProvider* raster_buffer_provider, |
153 ImageDecodeTask::Vector* dependencies) | 150 scoped_ptr<ScopedResource> resource, |
154 : RasterTask(dependencies), resource_(std::move(resource)) {} | 151 Task::Vector* dependencies) |
| 152 : raster_buffer_provider_(raster_buffer_provider), |
| 153 resource_(std::move(resource)) { |
| 154 dependencies_ = std::move(*dependencies); |
| 155 } |
| 156 |
| 157 const Task::Vector& dependencies() const { return dependencies_; } |
155 | 158 |
156 // Overridden from Task: | 159 // Overridden from Task: |
157 void RunOnWorkerThread() override {} | 160 void ScheduleOnOriginThread() override { |
158 | |
159 // Overridden from TileTask: | |
160 void ScheduleOnOriginThread(TileTaskClient* client) override { | |
161 // No tile ids are given to support partial updates. | 161 // No tile ids are given to support partial updates. |
162 raster_buffer_ = client->AcquireBufferForRaster(resource_.get(), 0, 0); | 162 raster_buffer_ = |
| 163 raster_buffer_provider_->AcquireBufferForRaster(resource_.get(), 0, 0); |
163 } | 164 } |
164 void CompleteOnOriginThread(TileTaskClient* client) override { | 165 void CompleteOnOriginThread() override { |
165 client->ReleaseBufferForRaster(std::move(raster_buffer_)); | 166 raster_buffer_provider_->ReleaseBufferForRaster(std::move(raster_buffer_)); |
166 Reset(); | 167 Reset(); |
167 } | 168 } |
| 169 void RunOnWorkerThread() override {} |
168 | 170 |
169 void Reset() { | 171 void Reset() { |
170 did_run_ = false; | 172 did_run_ = false; |
171 did_complete_ = false; | 173 did_complete_ = false; |
172 } | 174 } |
173 | 175 |
174 protected: | 176 protected: |
175 ~PerfRasterTaskImpl() override {} | 177 ~PerfRasterTaskImpl() override {} |
176 | 178 |
177 private: | 179 private: |
| 180 RasterBufferProvider* raster_buffer_provider_; |
178 scoped_ptr<ScopedResource> resource_; | 181 scoped_ptr<ScopedResource> resource_; |
179 scoped_ptr<RasterBuffer> raster_buffer_; | 182 scoped_ptr<RasterBuffer> raster_buffer_; |
| 183 Task::Vector dependencies_; |
180 | 184 |
181 DISALLOW_COPY_AND_ASSIGN(PerfRasterTaskImpl); | 185 DISALLOW_COPY_AND_ASSIGN(PerfRasterTaskImpl); |
182 }; | 186 }; |
183 | 187 |
184 class TileTaskWorkerPoolPerfTestBase { | 188 class TileTaskWorkerPoolPerfTestBase { |
185 public: | 189 public: |
186 typedef std::vector<scoped_refptr<RasterTask>> RasterTaskVector; | 190 typedef std::vector<scoped_refptr<PerfRasterTaskImpl>> RasterTaskVector; |
187 | 191 |
188 enum NamedTaskSet { REQUIRED_FOR_ACTIVATION, REQUIRED_FOR_DRAW, ALL }; | 192 enum NamedTaskSet { REQUIRED_FOR_ACTIVATION, REQUIRED_FOR_DRAW, ALL }; |
189 | 193 |
190 TileTaskWorkerPoolPerfTestBase() | 194 TileTaskWorkerPoolPerfTestBase() |
191 : context_provider_(make_scoped_refptr(new PerfContextProvider)), | 195 : context_provider_(make_scoped_refptr(new PerfContextProvider)), |
192 task_runner_(new base::TestSimpleTaskRunner), | 196 task_runner_(new base::TestSimpleTaskRunner), |
193 task_graph_runner_(new SynchronousTaskGraphRunner), | 197 task_graph_runner_(new SynchronousTaskGraphRunner), |
194 timer_(kWarmupRuns, | 198 timer_(kWarmupRuns, |
195 base::TimeDelta::FromMilliseconds(kTimeLimitMillis), | 199 base::TimeDelta::FromMilliseconds(kTimeLimitMillis), |
196 kTimeCheckInterval) {} | 200 kTimeCheckInterval) {} |
197 | 201 |
198 void CreateImageDecodeTasks(unsigned num_image_decode_tasks, | 202 void CreateImageDecodeTasks(unsigned num_image_decode_tasks, |
199 ImageDecodeTask::Vector* image_decode_tasks) { | 203 Task::Vector* image_decode_tasks) { |
200 for (unsigned i = 0; i < num_image_decode_tasks; ++i) | 204 for (unsigned i = 0; i < num_image_decode_tasks; ++i) |
201 image_decode_tasks->push_back(new PerfImageDecodeTaskImpl); | 205 image_decode_tasks->push_back(new PerfImageDecodeTaskImpl); |
202 } | 206 } |
203 | 207 |
204 void CreateRasterTasks(unsigned num_raster_tasks, | 208 void CreateRasterTasks(RasterBufferProvider* raster_buffer_provider, |
205 const ImageDecodeTask::Vector& image_decode_tasks, | 209 unsigned num_raster_tasks, |
| 210 const Task::Vector& image_decode_tasks, |
206 RasterTaskVector* raster_tasks) { | 211 RasterTaskVector* raster_tasks) { |
207 const gfx::Size size(1, 1); | 212 const gfx::Size size(1, 1); |
208 | 213 |
209 for (unsigned i = 0; i < num_raster_tasks; ++i) { | 214 for (unsigned i = 0; i < num_raster_tasks; ++i) { |
210 scoped_ptr<ScopedResource> resource( | 215 scoped_ptr<ScopedResource> resource( |
211 ScopedResource::Create(resource_provider_.get())); | 216 ScopedResource::Create(resource_provider_.get())); |
212 resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, | 217 resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, |
213 RGBA_8888); | 218 RGBA_8888); |
214 | 219 |
215 ImageDecodeTask::Vector dependencies = image_decode_tasks; | 220 Task::Vector dependencies = image_decode_tasks; |
216 raster_tasks->push_back( | 221 raster_tasks->push_back(new PerfRasterTaskImpl( |
217 new PerfRasterTaskImpl(std::move(resource), &dependencies)); | 222 raster_buffer_provider, std::move(resource), &dependencies)); |
218 } | 223 } |
219 } | 224 } |
220 | 225 |
221 void BuildTileTaskGraph(TaskGraph* graph, | 226 void BuildTileTaskGraph(TaskGraph* graph, |
222 const RasterTaskVector& raster_tasks) { | 227 const RasterTaskVector& raster_tasks) { |
223 uint16_t priority = 0; | 228 uint16_t priority = 0; |
224 | 229 |
225 for (auto& raster_task : raster_tasks) { | 230 for (auto& raster_task : raster_tasks) { |
226 priority++; | 231 priority++; |
227 | 232 |
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
292 } | 297 } |
293 | 298 |
294 void RunMessageLoopUntilAllTasksHaveCompleted() { | 299 void RunMessageLoopUntilAllTasksHaveCompleted() { |
295 task_graph_runner_->RunUntilIdle(); | 300 task_graph_runner_->RunUntilIdle(); |
296 task_runner_->RunUntilIdle(); | 301 task_runner_->RunUntilIdle(); |
297 } | 302 } |
298 | 303 |
299 void RunScheduleTasksTest(const std::string& test_name, | 304 void RunScheduleTasksTest(const std::string& test_name, |
300 unsigned num_raster_tasks, | 305 unsigned num_raster_tasks, |
301 unsigned num_image_decode_tasks) { | 306 unsigned num_image_decode_tasks) { |
302 ImageDecodeTask::Vector image_decode_tasks; | 307 Task::Vector image_decode_tasks; |
303 RasterTaskVector raster_tasks; | 308 RasterTaskVector raster_tasks; |
304 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks); | 309 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks); |
305 CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks); | 310 CreateRasterTasks(tile_task_worker_pool_->AsTileTaskRunner(), |
| 311 num_raster_tasks, image_decode_tasks, &raster_tasks); |
306 | 312 |
307 // Avoid unnecessary heap allocations by reusing the same graph. | 313 // Avoid unnecessary heap allocations by reusing the same graph. |
308 TaskGraph graph; | 314 TaskGraph graph; |
309 | 315 |
310 timer_.Reset(); | 316 timer_.Reset(); |
311 do { | 317 do { |
312 graph.Reset(); | 318 graph.Reset(); |
313 BuildTileTaskGraph(&graph, raster_tasks); | 319 BuildTileTaskGraph(&graph, raster_tasks); |
314 tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&graph); | 320 tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&graph); |
315 tile_task_worker_pool_->AsTileTaskRunner()->CheckForCompletedTasks(); | 321 tile_task_worker_pool_->AsTileTaskRunner()->CheckForCompletedTasks(); |
316 timer_.NextLap(); | 322 timer_.NextLap(); |
317 } while (!timer_.HasTimeLimitExpired()); | 323 } while (!timer_.HasTimeLimitExpired()); |
318 | 324 |
319 TaskGraph empty; | 325 TaskGraph empty; |
320 tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&empty); | 326 tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&empty); |
321 RunMessageLoopUntilAllTasksHaveCompleted(); | 327 RunMessageLoopUntilAllTasksHaveCompleted(); |
322 | 328 |
323 perf_test::PrintResult("schedule_tasks", TestModifierString(), test_name, | 329 perf_test::PrintResult("schedule_tasks", TestModifierString(), test_name, |
324 timer_.LapsPerSecond(), "runs/s", true); | 330 timer_.LapsPerSecond(), "runs/s", true); |
325 } | 331 } |
326 | 332 |
327 void RunScheduleAlternateTasksTest(const std::string& test_name, | 333 void RunScheduleAlternateTasksTest(const std::string& test_name, |
328 unsigned num_raster_tasks, | 334 unsigned num_raster_tasks, |
329 unsigned num_image_decode_tasks) { | 335 unsigned num_image_decode_tasks) { |
330 const size_t kNumVersions = 2; | 336 const size_t kNumVersions = 2; |
331 ImageDecodeTask::Vector image_decode_tasks[kNumVersions]; | 337 Task::Vector image_decode_tasks[kNumVersions]; |
332 RasterTaskVector raster_tasks[kNumVersions]; | 338 RasterTaskVector raster_tasks[kNumVersions]; |
333 for (size_t i = 0; i < kNumVersions; ++i) { | 339 for (size_t i = 0; i < kNumVersions; ++i) { |
334 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks[i]); | 340 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks[i]); |
335 CreateRasterTasks(num_raster_tasks, image_decode_tasks[i], | 341 CreateRasterTasks(tile_task_worker_pool_->AsTileTaskRunner(), |
| 342 num_raster_tasks, image_decode_tasks[i], |
336 &raster_tasks[i]); | 343 &raster_tasks[i]); |
337 } | 344 } |
338 | 345 |
339 // Avoid unnecessary heap allocations by reusing the same graph. | 346 // Avoid unnecessary heap allocations by reusing the same graph. |
340 TaskGraph graph; | 347 TaskGraph graph; |
341 | 348 |
342 size_t count = 0; | 349 size_t count = 0; |
343 timer_.Reset(); | 350 timer_.Reset(); |
344 do { | 351 do { |
345 graph.Reset(); | 352 graph.Reset(); |
346 BuildTileTaskGraph(&graph, raster_tasks[count % kNumVersions]); | 353 BuildTileTaskGraph(&graph, raster_tasks[count % kNumVersions]); |
347 tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&graph); | 354 tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&graph); |
348 tile_task_worker_pool_->AsTileTaskRunner()->CheckForCompletedTasks(); | 355 tile_task_worker_pool_->AsTileTaskRunner()->CheckForCompletedTasks(); |
349 ++count; | 356 ++count; |
350 timer_.NextLap(); | 357 timer_.NextLap(); |
351 } while (!timer_.HasTimeLimitExpired()); | 358 } while (!timer_.HasTimeLimitExpired()); |
352 | 359 |
353 TaskGraph empty; | 360 TaskGraph empty; |
354 tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&empty); | 361 tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&empty); |
355 RunMessageLoopUntilAllTasksHaveCompleted(); | 362 RunMessageLoopUntilAllTasksHaveCompleted(); |
356 | 363 |
357 perf_test::PrintResult("schedule_alternate_tasks", TestModifierString(), | 364 perf_test::PrintResult("schedule_alternate_tasks", TestModifierString(), |
358 test_name, timer_.LapsPerSecond(), "runs/s", true); | 365 test_name, timer_.LapsPerSecond(), "runs/s", true); |
359 } | 366 } |
360 | 367 |
361 void RunScheduleAndExecuteTasksTest(const std::string& test_name, | 368 void RunScheduleAndExecuteTasksTest(const std::string& test_name, |
362 unsigned num_raster_tasks, | 369 unsigned num_raster_tasks, |
363 unsigned num_image_decode_tasks) { | 370 unsigned num_image_decode_tasks) { |
364 ImageDecodeTask::Vector image_decode_tasks; | 371 Task::Vector image_decode_tasks; |
365 RasterTaskVector raster_tasks; | 372 RasterTaskVector raster_tasks; |
366 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks); | 373 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks); |
367 CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks); | 374 CreateRasterTasks(tile_task_worker_pool_->AsTileTaskRunner(), |
| 375 num_raster_tasks, image_decode_tasks, &raster_tasks); |
368 | 376 |
369 // Avoid unnecessary heap allocations by reusing the same graph. | 377 // Avoid unnecessary heap allocations by reusing the same graph. |
370 TaskGraph graph; | 378 TaskGraph graph; |
371 | 379 |
372 timer_.Reset(); | 380 timer_.Reset(); |
373 do { | 381 do { |
374 graph.Reset(); | 382 graph.Reset(); |
375 BuildTileTaskGraph(&graph, raster_tasks); | 383 BuildTileTaskGraph(&graph, raster_tasks); |
376 tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&graph); | 384 tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&graph); |
377 RunMessageLoopUntilAllTasksHaveCompleted(); | 385 RunMessageLoopUntilAllTasksHaveCompleted(); |
(...skipping 85 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
463 void SetUp() override { | 471 void SetUp() override { |
464 output_surface_ = FakeOutputSurface::Create3d(context_provider_); | 472 output_surface_ = FakeOutputSurface::Create3d(context_provider_); |
465 CHECK(output_surface_->BindToClient(&output_surface_client_)); | 473 CHECK(output_surface_->BindToClient(&output_surface_client_)); |
466 resource_provider_ = | 474 resource_provider_ = |
467 FakeResourceProvider::Create(output_surface_.get(), nullptr); | 475 FakeResourceProvider::Create(output_surface_.get(), nullptr); |
468 } | 476 } |
469 | 477 |
470 void RunBuildTileTaskGraphTest(const std::string& test_name, | 478 void RunBuildTileTaskGraphTest(const std::string& test_name, |
471 unsigned num_raster_tasks, | 479 unsigned num_raster_tasks, |
472 unsigned num_image_decode_tasks) { | 480 unsigned num_image_decode_tasks) { |
473 ImageDecodeTask::Vector image_decode_tasks; | 481 Task::Vector image_decode_tasks; |
474 RasterTaskVector raster_tasks; | 482 RasterTaskVector raster_tasks; |
475 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks); | 483 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks); |
476 CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks); | 484 // TODO(prashant.n): Pass real RasterBufferProvider instead of nullptr. |
| 485 CreateRasterTasks(nullptr, num_raster_tasks, image_decode_tasks, |
| 486 &raster_tasks); |
477 | 487 |
478 // Avoid unnecessary heap allocations by reusing the same graph. | 488 // Avoid unnecessary heap allocations by reusing the same graph. |
479 TaskGraph graph; | 489 TaskGraph graph; |
480 | 490 |
481 timer_.Reset(); | 491 timer_.Reset(); |
482 do { | 492 do { |
483 graph.Reset(); | 493 graph.Reset(); |
484 BuildTileTaskGraph(&graph, raster_tasks); | 494 BuildTileTaskGraph(&graph, raster_tasks); |
485 timer_.NextLap(); | 495 timer_.NextLap(); |
486 } while (!timer_.HasTimeLimitExpired()); | 496 } while (!timer_.HasTimeLimitExpired()); |
487 | 497 |
488 perf_test::PrintResult("build_raster_task_graph", "", test_name, | 498 perf_test::PrintResult("build_raster_task_graph", "", test_name, |
489 timer_.LapsPerSecond(), "runs/s", true); | 499 timer_.LapsPerSecond(), "runs/s", true); |
490 } | 500 } |
491 }; | 501 }; |
492 | 502 |
493 TEST_F(TileTaskWorkerPoolCommonPerfTest, BuildTileTaskGraph) { | 503 TEST_F(TileTaskWorkerPoolCommonPerfTest, BuildTileTaskGraph) { |
494 RunBuildTileTaskGraphTest("1_0", 1, 0); | 504 RunBuildTileTaskGraphTest("1_0", 1, 0); |
495 RunBuildTileTaskGraphTest("32_0", 32, 0); | 505 RunBuildTileTaskGraphTest("32_0", 32, 0); |
496 RunBuildTileTaskGraphTest("1_1", 1, 1); | 506 RunBuildTileTaskGraphTest("1_1", 1, 1); |
497 RunBuildTileTaskGraphTest("32_1", 32, 1); | 507 RunBuildTileTaskGraphTest("32_1", 32, 1); |
498 RunBuildTileTaskGraphTest("1_4", 1, 4); | 508 RunBuildTileTaskGraphTest("1_4", 1, 4); |
499 RunBuildTileTaskGraphTest("32_4", 32, 4); | 509 RunBuildTileTaskGraphTest("32_4", 32, 4); |
500 } | 510 } |
501 | 511 |
502 } // namespace | 512 } // namespace |
503 } // namespace cc | 513 } // namespace cc |
OLD | NEW |