WIP GPU scheduler + delayed activation / tile draw

gpu/ipc/service/gpu_command_buffer_stub.cc

Index: gpu/ipc/service/gpu_command_buffer_stub.cc
diff --git a/gpu/ipc/service/gpu_command_buffer_stub.cc b/gpu/ipc/service/gpu_command_buffer_stub.cc
index b6396195afabdcb5ec8d6c46d8e5f253f00e02fe..cfe78e4576670cc351f01c240817f7ac7693ae2b 100644
--- a/gpu/ipc/service/gpu_command_buffer_stub.cc
+++ b/gpu/ipc/service/gpu_command_buffer_stub.cc
@@ -20,6 +20,7 @@
 #include "gpu/command_buffer/common/gpu_memory_buffer_support.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "gpu/command_buffer/common/sync_token.h"
+#include "gpu/command_buffer/service/command_executor.h"
 #include "gpu/command_buffer/service/gl_context_virtual.h"
 #include "gpu/command_buffer/service/gl_state_restorer_impl.h"
 #include "gpu/command_buffer/service/image_manager.h"
@@ -80,10 +81,8 @@ class GpuCommandBufferMemoryTracker : public gles2::MemoryTracker {
         client_id_(channel->client_id()),
         share_group_tracing_guid_(share_group_tracing_guid) {}
 
-  void TrackMemoryAllocatedChange(
-      size_t old_size, size_t new_size) override {
-    tracking_group_->TrackMemoryAllocatedChange(
-        old_size, new_size);
+  void TrackMemoryAllocatedChange(size_t old_size, size_t new_size) override {
+    tracking_group_->TrackMemoryAllocatedChange(old_size, new_size);
   }
 
   bool EnsureGPUMemoryAvailable(size_t size_needed) override {
@@ -159,12 +158,21 @@ DevToolsChannelData::CreateForChannel(GpuChannel* channel) {
   return base::WrapUnique(new DevToolsChannelData(res.release()));
 }
 
-CommandBufferId GetCommandBufferID(int channel_id, int32_t route_id) {
+}  // anonymous namespace
+
+CommandBufferId GpuCommandBufferStub::GetCommandBufferID(int32_t channel_id,
+                                                         int32_t route_id) {
   return CommandBufferId::FromUnsafeValue(
       (static_cast<uint64_t>(channel_id) << 32) | route_id);
 }
 
-}  // namespace
+int32_t GpuCommandBufferStub::GetChannelID(gpu::CommandBufferId cmd_buffer_id) {
+  return static_cast<int32_t>(cmd_buffer_id.GetUnsafeValue() >> 32);
+}
+
+int32_t GpuCommandBufferStub::GetRouteID(gpu::CommandBufferId cmd_buffer_id) {
+  return static_cast<int32_t>(cmd_buffer_id.GetUnsafeValue());
+}
 
 std::unique_ptr<GpuCommandBufferStub> GpuCommandBufferStub::Create(
     GpuChannel* channel,
@@ -202,14 +210,12 @@ GpuCommandBufferStub::~GpuCommandBufferStub() {
 }
 
 GpuMemoryManager* GpuCommandBufferStub::GetMemoryManager() const {
-    return channel()->gpu_channel_manager()->gpu_memory_manager();
+  return channel()->gpu_channel_manager()->gpu_memory_manager();
 }
 
 bool GpuCommandBufferStub::OnMessageReceived(const IPC::Message& message) {
-  TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"),
-               "GPUTask",
-               "data",
-               DevToolsChannelData::CreateForChannel(channel()));
+  TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "GPUTask",
+               "data", DevToolsChannelData::CreateForChannel(channel()));
   FastSetActiveURL(active_url_, active_url_hash_, channel_);
 
   bool have_context = false;
@@ -246,12 +252,9 @@ bool GpuCommandBufferStub::OnMessageReceived(const IPC::Message& message) {
                         OnRegisterTransferBuffer);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_DestroyTransferBuffer,
                         OnDestroyTransferBuffer);
-    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_WaitSyncToken,
-                        OnWaitSyncToken)
-    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SignalSyncToken,
-                        OnSignalSyncToken)
-    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SignalQuery,
-                        OnSignalQuery)
+    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_WaitSyncToken, OnWaitSyncToken)
+    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SignalSyncToken, OnSignalSyncToken)
+    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SignalQuery, OnSignalQuery)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_CreateImage, OnCreateImage);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_DestroyImage, OnDestroyImage);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_CreateStreamTexture,
@@ -380,7 +383,7 @@ bool GpuCommandBufferStub::HasUnprocessedCommands() {
   if (command_buffer_) {
     CommandBuffer::State state = command_buffer_->GetLastState();
     return command_buffer_->GetPutOffset() != state.get_offset &&
-        !error::IsError(state.error);
+           !error::IsError(state.error);
   }
   return false;
 }
@@ -452,8 +455,9 @@ void GpuCommandBufferStub::Destroy() {
     // (exit_on_context_lost workaround), then don't tell the browser about
     // offscreen context destruction here since it's not client-invoked, and
     // might bypass the 3D API blocking logic.
-    if ((surface_handle_ == gpu::kNullSurfaceHandle) && !active_url_.is_empty()
-        && !gpu_channel_manager->is_exiting_for_lost_context()) {
+    if ((surface_handle_ == gpu::kNullSurfaceHandle) &&
+        !active_url_.is_empty() &&
+        !gpu_channel_manager->is_exiting_for_lost_context()) {
       gpu_channel_manager->delegate()->DidDestroyOffscreenContext(active_url_);
     }
   }
@@ -542,8 +546,7 @@ bool GpuCommandBufferStub::Initialize(
 #if defined(OS_ANDROID)
   if (init_params.attribs.red_size <= 5 &&
       init_params.attribs.green_size <= 6 &&
-      init_params.attribs.blue_size <= 5 &&
-      init_params.attribs.alpha_size == 0)
+      init_params.attribs.blue_size <= 5 && init_params.attribs.alpha_size == 0)
     surface_format = gl::GLSurface::SURFACE_RGB565;
   // We can only use virtualized contexts for onscreen command buffers if their
   // config is compatible with the offscreen ones - otherwise MakeCurrent fails.
@@ -551,8 +554,8 @@ bool GpuCommandBufferStub::Initialize(
     use_virtualized_gl_context_ = false;
 #endif
 
-  command_buffer_.reset(new CommandBufferService(
-      context_group_->transfer_buffer_manager()));
+  command_buffer_.reset(
+      new CommandBufferService(context_group_->transfer_buffer_manager()));
 
   decoder_.reset(gles2::GLES2Decoder::Create(context_group_.get()));
   executor_.reset(new CommandExecutor(command_buffer_.get(), decoder_.get(),
@@ -561,7 +564,7 @@ bool GpuCommandBufferStub::Initialize(
       channel_->GetSyncPointOrderData(stream_id_),
       CommandBufferNamespace::GPU_IO, command_buffer_id_);
 
-  executor_->SetPreemptByFlag(channel_->preempted_flag());
+  executor_->SetPreemptionCallback(channel_->GetPreemptionCallback());
 
   decoder_->set_engine(executor_.get());
 
@@ -600,8 +603,8 @@ bool GpuCommandBufferStub::Initialize(
     // (2) a mock context.
     DCHECK(context->GetHandle() ||
            gl::GetGLImplementation() == gl::kGLImplementationMockGL);
-    context = new GLContextVirtual(
-        gl_share_group, context.get(), decoder_->AsWeakPtr());
+    context = new GLContextVirtual(gl_share_group, context.get(),
+                                   decoder_->AsWeakPtr());
     if (!context->Initialize(
             surface_.get(),
             GenerateGLContextAttribs(init_params.attribs,
@@ -630,8 +633,7 @@ bool GpuCommandBufferStub::Initialize(
   }
 
   if (!context->GetGLStateRestorer()) {
-    context->SetGLStateRestorer(
-        new GLStateRestorerImpl(decoder_->AsWeakPtr()));
+    context->SetGLStateRestorer(new GLStateRestorerImpl(decoder_->AsWeakPtr()));
   }
 
   if (!context_group_->has_program_cache() &&
@@ -651,12 +653,10 @@ bool GpuCommandBufferStub::Initialize(
     decoder_->set_log_commands(true);
   }
 
-  decoder_->GetLogger()->SetMsgCallback(
-      base::Bind(&GpuCommandBufferStub::SendConsoleMessage,
-                 base::Unretained(this)));
-  decoder_->SetShaderCacheCallback(
-      base::Bind(&GpuCommandBufferStub::SendCachedShader,
-                 base::Unretained(this)));
+  decoder_->GetLogger()->SetMsgCallback(base::Bind(
+      &GpuCommandBufferStub::SendConsoleMessage, base::Unretained(this)));
+  decoder_->SetShaderCacheCallback(base::Bind(
+      &GpuCommandBufferStub::SendCachedShader, base::Unretained(this)));
   decoder_->SetFenceSyncReleaseCallback(base::Bind(
       &GpuCommandBufferStub::OnFenceSyncRelease, base::Unretained(this)));
   decoder_->SetWaitFenceSyncCallback(base::Bind(
@@ -781,8 +781,8 @@ void GpuCommandBufferStub::CheckCompleteWaits() {
   if (wait_for_token_ || wait_for_get_offset_) {
     CommandBuffer::State state = command_buffer_->GetLastState();
     if (wait_for_token_ &&
-        (CommandBuffer::InRange(
-             wait_for_token_->start, wait_for_token_->end, state.token) ||
+        (CommandBuffer::InRange(wait_for_token_->start, wait_for_token_->end,
+                                state.token) ||
          state.error != error::kNoError)) {
       ReportState();
       GpuCommandBufferMsg_WaitForTokenInRange::WriteReplyParams(
@@ -792,8 +792,7 @@ void GpuCommandBufferStub::CheckCompleteWaits() {
     }
     if (wait_for_get_offset_ &&
         (CommandBuffer::InRange(wait_for_get_offset_->start,
-                                     wait_for_get_offset_->end,
-                                     state.get_offset) ||
+                                wait_for_get_offset_->end, state.get_offset) ||
          state.error != error::kNoError)) {
       ReportState();
       GpuCommandBufferMsg_WaitForGetOffsetInRange::WriteReplyParams(
@@ -808,8 +807,8 @@ void GpuCommandBufferStub::OnAsyncFlush(
     int32_t put_offset,
     uint32_t flush_count,
     const std::vector<ui::LatencyInfo>& latency_info) {
-  TRACE_EVENT1(
-      "gpu", "GpuCommandBufferStub::OnAsyncFlush", "put_offset", put_offset);
+  TRACE_EVENT1("gpu", "GpuCommandBufferStub::OnAsyncFlush", "put_offset",
+               put_offset);
   DCHECK(command_buffer_);
 
   // We received this message out-of-order. This should not happen but is here
@@ -871,7 +870,9 @@ void GpuCommandBufferStub::OnCommandProcessed() {
   channel_->watchdog()->CheckArmed();
 }
 
-void GpuCommandBufferStub::ReportState() { command_buffer_->UpdateState(); }
+void GpuCommandBufferStub::ReportState() {
+  command_buffer_->UpdateState();
+}
 
 void GpuCommandBufferStub::PutChanged() {
   FastSetActiveURL(active_url_, active_url_hash_, channel_);
@@ -882,8 +883,7 @@ void GpuCommandBufferStub::PullTextureUpdates(
     CommandBufferNamespace namespace_id,
     CommandBufferId command_buffer_id,
     uint32_t release) {
-  gles2::MailboxManager* mailbox_manager =
-      context_group_->mailbox_manager();
+  gles2::MailboxManager* mailbox_manager = context_group_->mailbox_manager();
   if (mailbox_manager->UsesSync() && MakeCurrent()) {
     SyncToken sync_token(namespace_id, 0, command_buffer_id, release);
     mailbox_manager->PullTextureUpdates(sync_token);
@@ -902,9 +902,9 @@ void GpuCommandBufferStub::OnSignalSyncToken(const SyncToken& sync_token,
           sync_token.namespace_id(), sync_token.command_buffer_id());
 
   if (release_state) {
-    sync_point_client_->Wait(release_state.get(), sync_token.release_count(),
-                             base::Bind(&GpuCommandBufferStub::OnSignalAck,
-                                        this->AsWeakPtr(), id));
+    sync_point_client_->Wait(
+        release_state.get(), sync_token.release_count(),
+        base::Bind(&GpuCommandBufferStub::OnSignalAck, this->AsWeakPtr(), id));
   } else {
     OnSignalAck(id);
   }
@@ -918,13 +918,10 @@ void GpuCommandBufferStub::OnSignalQuery(uint32_t query_id, uint32_t id) {
   if (decoder_) {
     gles2::QueryManager* query_manager = decoder_->GetQueryManager();
     if (query_manager) {
-      gles2::QueryManager::Query* query =
-          query_manager->GetQuery(query_id);
+      gles2::QueryManager::Query* query = query_manager->GetQuery(query_id);
       if (query) {
-        query->AddCallback(
-          base::Bind(&GpuCommandBufferStub::OnSignalAck,
-                     this->AsWeakPtr(),
-                     id));
+        query->AddCallback(base::Bind(&GpuCommandBufferStub::OnSignalAck,
+                                      this->AsWeakPtr(), id));
         return;
       }
     }
@@ -939,36 +936,33 @@ void GpuCommandBufferStub::OnFenceSyncRelease(uint64_t release) {
     return;
   }
 
-  gles2::MailboxManager* mailbox_manager =
-      context_group_->mailbox_manager();
+  gles2::MailboxManager* mailbox_manager = context_group_->mailbox_manager();
   if (mailbox_manager->UsesSync() && MakeCurrent()) {
-    SyncToken sync_token(CommandBufferNamespace::GPU_IO, 0,
-                              command_buffer_id_, release);
+    SyncToken sync_token(CommandBufferNamespace::GPU_IO, 0, command_buffer_id_,
+                         release);
     mailbox_manager->PushTextureUpdates(sync_token);
   }
 
   sync_point_client_->ReleaseFenceSync(release);
+  command_buffer_->SetReleaseCount(release);
 }
 
 void GpuCommandBufferStub::OnDescheduleUntilFinished() {
   DCHECK(executor_->scheduled());
   DCHECK(executor_->HasPollingWork());
-
   executor_->SetScheduled(false);
-  channel_->OnStreamRescheduled(stream_id_, false);
+  channel_->DescheduleCommandBuffer(this);
 }
 
 void GpuCommandBufferStub::OnRescheduleAfterFinished() {
   DCHECK(!executor_->scheduled());
-
   executor_->SetScheduled(true);
-  channel_->OnStreamRescheduled(stream_id_, true);
+  channel_->ScheduleCommandBuffer(this);
 }
 
-bool GpuCommandBufferStub::OnWaitFenceSync(
-    CommandBufferNamespace namespace_id,
-    CommandBufferId command_buffer_id,
-    uint64_t release) {
+bool GpuCommandBufferStub::OnWaitFenceSync(CommandBufferNamespace namespace_id,
+                                           CommandBufferId command_buffer_id,
+                                           uint64_t release) {
   DCHECK(!waiting_for_sync_point_);
   DCHECK(executor_->scheduled());
 
@@ -996,7 +990,7 @@ bool GpuCommandBufferStub::OnWaitFenceSync(
     return true;
 
   executor_->SetScheduled(false);
-  channel_->OnStreamRescheduled(stream_id_, false);
+  channel_->DescheduleCommandBuffer(this);
   return false;
 }
 
@@ -1010,7 +1004,7 @@ void GpuCommandBufferStub::OnWaitFenceSyncCompleted(
   PullTextureUpdates(namespace_id, command_buffer_id, release);
   waiting_for_sync_point_ = false;
   executor_->SetScheduled(true);
-  channel_->OnStreamRescheduled(stream_id_, true);
+  channel_->ScheduleCommandBuffer(this);
 }
 
 void GpuCommandBufferStub::OnCreateImage(
@@ -1086,14 +1080,14 @@ void GpuCommandBufferStub::SendConsoleMessage(int32_t id,
   GPUCommandBufferConsoleMessage console_message;
   console_message.id = id;
   console_message.message = message;
-  IPC::Message* msg = new GpuCommandBufferMsg_ConsoleMsg(
-      route_id_, console_message);
+  IPC::Message* msg =
+      new GpuCommandBufferMsg_ConsoleMsg(route_id_, console_message);
   msg->set_unblock(true);
   Send(msg);
 }
 
-void GpuCommandBufferStub::SendCachedShader(
-    const std::string& key, const std::string& shader) {
+void GpuCommandBufferStub::SendCachedShader(const std::string& key,
+                                            const std::string& shader) {
   channel_->CacheShader(key, shader);
 }