cc/resources/raster_worker_pool_perftest.cc - Issue 165603002: cc: Move GPU raster to DirectRasterWorkerPool.

Unified Diff: cc/resources/raster_worker_pool_perftest.cc

Issue 165603002: cc: Move GPU raster to DirectRasterWorkerPool. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src

Patch Set: Created 6 years, 10 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: cc/resources/raster_worker_pool_perftest.cc

diff --git a/cc/resources/raster_worker_pool_perftest.cc b/cc/resources/raster_worker_pool_perftest.cc

index 703a95da911ee4be93a66461d4e5943306761386..f8d0f8d779bebdd539b83c9246447028d83d6599 100644

--- a/cc/resources/raster_worker_pool_perftest.cc

+++ b/cc/resources/raster_worker_pool_perftest.cc

@@ -5,6 +5,7 @@

#include "cc/resources/raster_worker_pool.h"

#include "base/time/time.h"

+#include "cc/resources/direct_raster_worker_pool.h"

#include "cc/resources/image_raster_worker_pool.h"

#include "cc/resources/pixel_buffer_raster_worker_pool.h"

#include "cc/resources/resource_provider.h"

@@ -22,7 +23,8 @@ namespace {

enum RasterWorkerPoolType {

RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER,

- RASTER_WORKER_POOL_TYPE_IMAGE

+ RASTER_WORKER_POOL_TYPE_IMAGE,

+ RASTER_WORKER_POOL_TYPE_DIRECT

};

static const int kTimeLimitMillis = 2000;

@@ -39,6 +41,7 @@ class PerfWorkerPoolTaskImpl : public internal::WorkerPoolTask {

// Overridden from internal::WorkerPoolTask:

virtual void ScheduleOnOriginThread(internal::WorkerPoolTaskClient* client)

OVERRIDE {}

+ virtual void RunOnOriginThread() OVERRIDE {}

virtual void CompleteOnOriginThread(internal::WorkerPoolTaskClient* client)

OVERRIDE {}

virtual void RunReplyOnOriginThread() OVERRIDE { Reset(); }

@@ -58,8 +61,8 @@ class PerfWorkerPoolTaskImpl : public internal::WorkerPoolTask {

class PerfRasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {

public:

PerfRasterWorkerPoolTaskImpl(scoped_ptr<ScopedResource> resource,

- internal::Task::Vector* dependencies)

- : internal::RasterWorkerPoolTask(resource.get(), dependencies, false),

+ internal::WorkerPoolTask::Vector* dependencies)

+ : internal::RasterWorkerPoolTask(resource.get(), dependencies),

resource_(resource.Pass()) {}

// Overridden from internal::Task:

@@ -70,16 +73,13 @@ class PerfRasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {

OVERRIDE {

client->AcquireCanvasForRaster(this);

}

+ virtual void RunOnOriginThread() OVERRIDE {}

virtual void CompleteOnOriginThread(internal::WorkerPoolTaskClient* client)

OVERRIDE {

client->OnRasterCompleted(this, PicturePileImpl::Analysis());

}

virtual void RunReplyOnOriginThread() OVERRIDE { Reset(); }

- // Overridden from internal::RasterWorkerPoolTask:

- virtual void RunOnOriginThread(ResourceProvider* resource_provider,

- ContextProvider* context_provider) OVERRIDE {}

void Reset() {

did_run_ = false;

did_complete_ = false;

@@ -106,7 +106,6 @@ class PerfPixelBufferRasterWorkerPoolImpl : public PixelBufferRasterWorkerPool {

ResourceProvider* resource_provider)

: PixelBufferRasterWorkerPool(task_graph_runner,

resource_provider,

- NULL,

std::numeric_limits<size_t>::max()) {}

};

@@ -116,49 +115,22 @@ class PerfImageRasterWorkerPoolImpl : public ImageRasterWorkerPool {

ResourceProvider* resource_provider)

: ImageRasterWorkerPool(task_graph_runner,

resource_provider,

- NULL,

GL_TEXTURE_2D) {}

};

+class PerfDirectRasterWorkerPoolImpl : public DirectRasterWorkerPool {

+ public:

+ PerfDirectRasterWorkerPoolImpl(ResourceProvider* resource_provider,

+ ContextProvider* context_provider)

+ : DirectRasterWorkerPool(resource_provider, context_provider) {}

+};

class RasterWorkerPoolPerfTest

: public testing::TestWithParam<RasterWorkerPoolType>,

public RasterWorkerPoolClient {

public:

- class Task : public RasterWorkerPool::Task {

- public:

- typedef std::vector<Task> Vector;

- static Task Create() { return Task(new PerfWorkerPoolTaskImpl); }

- void AppendTo(internal::Task::Vector* dependencies) const {

- dependencies->push_back(internal_);

- }

- private:

- explicit Task(internal::WorkerPoolTask* task)

- : RasterWorkerPool::Task(task) {}

- };

- class RasterTask : public RasterWorkerPool::RasterTask {

- public:

- typedef std::vector<RasterTask> Vector;

- static RasterTask Create(scoped_ptr<ScopedResource> resource,

- const Task::Vector& image_decode_tasks) {

- internal::Task::Vector dependencies;

- for (Task::Vector::const_iterator it = image_decode_tasks.begin();

- it != image_decode_tasks.end();

- ++it)

- it->AppendTo(&dependencies);

- return RasterTask(

- new PerfRasterWorkerPoolTaskImpl(resource.Pass(), &dependencies));

- }

- private:

- explicit RasterTask(internal::RasterWorkerPoolTask* task)

- : RasterWorkerPool::RasterTask(task) {}

- };

+ typedef std::vector<scoped_refptr<internal::RasterWorkerPoolTask> >

+ RasterTaskVector;

RasterWorkerPoolPerfTest()

: context_provider_(TestContextProvider::Create()),

@@ -181,6 +153,10 @@ class RasterWorkerPoolPerfTest

raster_worker_pool_.reset(new PerfImageRasterWorkerPoolImpl(

task_graph_runner_.get(), resource_provider_.get()));

break;

+ case RASTER_WORKER_POOL_TYPE_DIRECT:

+ raster_worker_pool_.reset(new PerfDirectRasterWorkerPoolImpl(

+ resource_provider_.get(), context_provider_));

+ break;

}

DCHECK(raster_worker_pool_);

@@ -199,18 +175,29 @@ class RasterWorkerPoolPerfTest

const OVERRIDE {

return false;

}

- virtual void DidFinishRunningTasks() OVERRIDE {}

+ virtual void DidFinishRunningTasks() OVERRIDE {

+ raster_worker_pool_->CheckForCompletedTasks();

+ base::MessageLoop::current()->Quit();

+ }

virtual void DidFinishRunningTasksRequiredForActivation() OVERRIDE {}

- void CreateImageDecodeTasks(unsigned num_image_decode_tasks,

- Task::Vector* image_decode_tasks) {

+ void RunMessageLoopUntilAllTasksHaveCompleted() {

+ while (task_graph_runner_->RunTaskForTesting())

+ continue;

+ base::MessageLoop::current()->Run();

+ }

+ void CreateImageDecodeTasks(

+ unsigned num_image_decode_tasks,

+ internal::WorkerPoolTask::Vector* image_decode_tasks) {

for (unsigned i = 0; i < num_image_decode_tasks; ++i)

- image_decode_tasks->push_back(Task::Create());

+ image_decode_tasks->push_back(new PerfWorkerPoolTaskImpl);

}

- void CreateRasterTasks(unsigned num_raster_tasks,

- const Task::Vector& image_decode_tasks,

- RasterTask::Vector* raster_tasks) {

+ void CreateRasterTasks(

+ unsigned num_raster_tasks,

+ const internal::WorkerPoolTask::Vector& image_decode_tasks,

+ RasterTaskVector* raster_tasks) {

const gfx::Size size(1, 1);

for (unsigned i = 0; i < num_raster_tasks; ++i) {

@@ -218,42 +205,43 @@ class RasterWorkerPoolPerfTest

ScopedResource::Create(resource_provider_.get()));

resource->Allocate(size, ResourceProvider::TextureUsageAny, RGBA_8888);

+ internal::WorkerPoolTask::Vector dependencies = image_decode_tasks;

raster_tasks->push_back(

- RasterTask::Create(resource.Pass(), image_decode_tasks));

+ new PerfRasterWorkerPoolTaskImpl(resource.Pass(), &dependencies));

}

- void AppendRasterTasks(RasterWorkerPool::RasterTask::Queue* tasks,

- const RasterTask::Vector& raster_tasks) {

- for (RasterTask::Vector::const_iterator it = raster_tasks.begin();

+ void BuildTaskQueue(RasterTaskQueue* queue,

+ const RasterTaskVector& raster_tasks) {

+ for (RasterTaskVector::const_iterator it = raster_tasks.begin();

it != raster_tasks.end();

++it)

- tasks->Append(*it, false);

+ queue->tasks.push_back(RasterTaskQueue::Task(it->get(), false));

}

void RunScheduleTasksTest(const std::string& test_name,

unsigned num_raster_tasks,

unsigned num_image_decode_tasks) {

- Task::Vector image_decode_tasks;

- RasterTask::Vector raster_tasks;

+ internal::WorkerPoolTask::Vector image_decode_tasks;

+ RasterTaskVector raster_tasks;

CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks);

CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks);

// Avoid unnecessary heap allocations by reusing the same queue.

- RasterWorkerPool::RasterTask::Queue tasks;

+ RasterTaskQueue queue;

timer_.Reset();

do {

- tasks.Reset();

- AppendRasterTasks(&tasks, raster_tasks);

- raster_worker_pool_->ScheduleTasks(&tasks);

+ queue.Reset();

+ BuildTaskQueue(&queue, raster_tasks);

+ raster_worker_pool_->ScheduleTasks(&queue);

raster_worker_pool_->CheckForCompletedTasks();

timer_.NextLap();

} while (!timer_.HasTimeLimitExpired());

- RasterWorkerPool::RasterTask::Queue empty;

+ RasterTaskQueue empty;

raster_worker_pool_->ScheduleTasks(&empty);

- raster_worker_pool_->CheckForCompletedTasks();

+ RunMessageLoopUntilAllTasksHaveCompleted();

perf_test::PrintResult("schedule_tasks",

"",

@@ -267,8 +255,8 @@ class RasterWorkerPoolPerfTest

unsigned num_raster_tasks,

unsigned num_image_decode_tasks) {

const size_t kNumVersions = 2;

- Task::Vector image_decode_tasks[kNumVersions];

- RasterTask::Vector raster_tasks[kNumVersions];

+ internal::WorkerPoolTask::Vector image_decode_tasks[kNumVersions];

+ RasterTaskVector raster_tasks[kNumVersions];

for (size_t i = 0; i < kNumVersions; ++i) {

CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks[i]);

CreateRasterTasks(

@@ -276,22 +264,22 @@ class RasterWorkerPoolPerfTest

}

// Avoid unnecessary heap allocations by reusing the same queue.

- RasterWorkerPool::RasterTask::Queue tasks;

+ RasterTaskQueue queue;

size_t count = 0;

timer_.Reset();

do {

- tasks.Reset();

- AppendRasterTasks(&tasks, raster_tasks[count % kNumVersions]);

- raster_worker_pool_->ScheduleTasks(&tasks);

+ queue.Reset();

+ BuildTaskQueue(&queue, raster_tasks[count % kNumVersions]);

+ raster_worker_pool_->ScheduleTasks(&queue);

raster_worker_pool_->CheckForCompletedTasks();

++count;

timer_.NextLap();

} while (!timer_.HasTimeLimitExpired());

- RasterWorkerPool::RasterTask::Queue empty;

+ RasterTaskQueue empty;

raster_worker_pool_->ScheduleTasks(&empty);

- raster_worker_pool_->CheckForCompletedTasks();

+ RunMessageLoopUntilAllTasksHaveCompleted();

perf_test::PrintResult("schedule_alternate_tasks",

"",

@@ -304,28 +292,26 @@ class RasterWorkerPoolPerfTest

void RunScheduleAndExecuteTasksTest(const std::string& test_name,

unsigned num_raster_tasks,

unsigned num_image_decode_tasks) {

- Task::Vector image_decode_tasks;

- RasterTask::Vector raster_tasks;

+ internal::WorkerPoolTask::Vector image_decode_tasks;

+ RasterTaskVector raster_tasks;

CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks);

CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks);

// Avoid unnecessary heap allocations by reusing the same queue.

- RasterWorkerPool::RasterTask::Queue tasks;

+ RasterTaskQueue queue;

timer_.Reset();

do {

- tasks.Reset();

- AppendRasterTasks(&tasks, raster_tasks);

- raster_worker_pool_->ScheduleTasks(&tasks);

- while (task_graph_runner_->RunTaskForTesting())

- continue;

- raster_worker_pool_->CheckForCompletedTasks();

+ queue.Reset();

+ BuildTaskQueue(&queue, raster_tasks);

+ raster_worker_pool_->ScheduleTasks(&queue);

+ RunMessageLoopUntilAllTasksHaveCompleted();

timer_.NextLap();

} while (!timer_.HasTimeLimitExpired());

- RasterWorkerPool::RasterTask::Queue empty;

+ RasterTaskQueue empty;

raster_worker_pool_->ScheduleTasks(&empty);

- raster_worker_pool_->CheckForCompletedTasks();

+ RunMessageLoopUntilAllTasksHaveCompleted();

perf_test::PrintResult("schedule_and_execute_tasks",

"",

@@ -342,7 +328,6 @@ class RasterWorkerPoolPerfTest

scoped_ptr<ResourceProvider> resource_provider_;

scoped_ptr<internal::TaskGraphRunner> task_graph_runner_;

scoped_ptr<RasterWorkerPool> raster_worker_pool_;

- std::vector<RasterWorkerPool::RasterTask> tasks_;

LapTimer timer_;

};

@@ -376,7 +361,8 @@ TEST_P(RasterWorkerPoolPerfTest, ScheduleAndExecuteTasks) {

INSTANTIATE_TEST_CASE_P(RasterWorkerPoolPerfTests,

RasterWorkerPoolPerfTest,

::testing::Values(RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER,

- RASTER_WORKER_POOL_TYPE_IMAGE));

+ RASTER_WORKER_POOL_TYPE_IMAGE,

+ RASTER_WORKER_POOL_TYPE_DIRECT));

} // namespace

} // namespace cc

« cc/resources/raster_worker_pool.h ('K') | « cc/resources/raster_worker_pool.cc ('k') | cc/resources/raster_worker_pool_unittest.cc » ('j') | cc/resources/tile_manager.cc » ('J')