gpu: GPU service scheduler.

gpu/ipc/service/gpu_channel.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/ipc/service/gpu_channel.h"
 
 #include <utility>
 
 #if defined(OS_WIN)
 #include <windows.h>
@@ skipping 16 matching lines @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/timer/timer.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "gpu/command_buffer/service/image_factory.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/preemption_flag.h"
+#include "gpu/command_buffer/service/scheduler.h"
 #include "gpu/ipc/common/gpu_messages.h"
 #include "gpu/ipc/service/gpu_channel_manager.h"
 #include "gpu/ipc/service/gpu_channel_manager_delegate.h"
 #include "gpu/ipc/service/gpu_memory_buffer_factory.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/message_filter.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image_shared_memory.h"
 #include "ui/gl/gl_surface.h"
 
@@ skipping 45 matching lines @@
 void SyncChannelFilteredSender::AddFilter(IPC::MessageFilter* filter) {
   channel_->AddFilter(filter);
 }
 
 void SyncChannelFilteredSender::RemoveFilter(IPC::MessageFilter* filter) {
   channel_->RemoveFilter(filter);
 }
 
 GpuChannelMessageQueue::GpuChannelMessageQueue(
     GpuChannel* channel,
+    scoped_refptr<SyncPointOrderData> sync_point_order_data,
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
     scoped_refptr<PreemptionFlag> preempting_flag,
-    scoped_refptr<PreemptionFlag> preempted_flag,
-    SyncPointManager* sync_point_manager)
+    scoped_refptr<PreemptionFlag> preempted_flag)
     : channel_(channel),
       max_preemption_time_(
           base::TimeDelta::FromMilliseconds(kMaxPreemptTimeMs)),
       timer_(new base::OneShotTimer),
-      sync_point_order_data_(sync_point_manager->CreateSyncPointOrderData()),
+      sync_point_order_data_(std::move(sync_point_order_data)),
       main_task_runner_(std::move(main_task_runner)),
       io_task_runner_(std::move(io_task_runner)),
       preempting_flag_(std::move(preempting_flag)),
-      preempted_flag_(std::move(preempted_flag)),
-      sync_point_manager_(sync_point_manager) {
+      preempted_flag_(std::move(preempted_flag)) {
   timer_->SetTaskRunner(io_task_runner_);
   io_thread_checker_.DetachFromThread();
 }
 
 GpuChannelMessageQueue::~GpuChannelMessageQueue() {
   DCHECK(channel_messages_.empty());
 }
 
 void GpuChannelMessageQueue::Destroy() {
   // We guarantee that the queue will no longer be modified after Destroy is
@@ skipping 305 matching lines @@
   DCHECK(preemption_state_ == CHECKING || preemption_state_ == PREEMPTING);
   DCHECK(!scheduled_);
 
   preemption_state_ = WOULD_PREEMPT_DESCHEDULED;
   preempting_flag_->Reset();
   TRACE_COUNTER_ID1("gpu", "GpuChannel::Preempting", this, 0);
 }
 
 GpuChannelMessageFilter::GpuChannelMessageFilter(
     GpuChannel* gpu_channel,
+    Scheduler* scheduler,
     scoped_refptr<GpuChannelMessageQueue> message_queue,
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner)
     : gpu_channel_(gpu_channel),
+      scheduler_(scheduler),
       message_queue_(std::move(message_queue)),
       main_task_runner_(std::move(main_task_runner)) {}
 
 GpuChannelMessageFilter::~GpuChannelMessageFilter() {
   DCHECK(!gpu_channel_);
 }
 
 void GpuChannelMessageFilter::Destroy() {
   base::AutoLock auto_lock(gpu_channel_lock_);
   gpu_channel_ = nullptr;
 }
 
+void GpuChannelMessageFilter::AddRoute(int32_t route_id,
+                                       SequenceId sequence_id) {
+  base::AutoLock auto_lock(gpu_channel_lock_);
+  DCHECK(gpu_channel_);
+  DCHECK(scheduler_);
+  route_sequences_[route_id] = sequence_id;
+}
+
+void GpuChannelMessageFilter::RemoveRoute(int32_t route_id) {
+  base::AutoLock auto_lock(gpu_channel_lock_);
+  DCHECK(gpu_channel_);
+  DCHECK(scheduler_);
+  route_sequences_.erase(route_id);
+}
+
 void GpuChannelMessageFilter::OnFilterAdded(IPC::Channel* channel) {
   DCHECK(!ipc_channel_);
   ipc_channel_ = channel;
   for (scoped_refptr<IPC::MessageFilter>& filter : channel_filters_)
     filter->OnFilterAdded(ipc_channel_);
 }
 
 void GpuChannelMessageFilter::OnFilterRemoved() {
   for (scoped_refptr<IPC::MessageFilter>& filter : channel_filters_)
     filter->OnFilterRemoved();
@@ skipping 30 matching lines @@
 void GpuChannelMessageFilter::RemoveChannelFilter(
     scoped_refptr<IPC::MessageFilter> filter) {
   if (ipc_channel_)
     filter->OnFilterRemoved();
   base::Erase(channel_filters_, filter);
 }
 
 bool GpuChannelMessageFilter::OnMessageReceived(const IPC::Message& message) {
   DCHECK(ipc_channel_);
 
+  if (!gpu_channel_)
+    return MessageErrorHandler(message, "Channel destroyed");
+
   if (message.should_unblock() || message.is_reply())
     return MessageErrorHandler(message, "Unexpected message type");
 
   if (message.type() == GpuChannelMsg_Nop::ID) {
     IPC::Message* reply = IPC::SyncMessage::GenerateReply(&message);
     Send(reply);
     return true;
   }
 
   for (scoped_refptr<IPC::MessageFilter>& filter : channel_filters_) {
     if (filter->OnMessageReceived(message))
       return true;
   }
 
   base::AutoLock auto_lock(gpu_channel_lock_);
   if (!gpu_channel_)
     return MessageErrorHandler(message, "Channel destroyed");
 
   if (message.routing_id() == MSG_ROUTING_CONTROL ||
       message.type() == GpuCommandBufferMsg_WaitForTokenInRange::ID ||
       message.type() == GpuCommandBufferMsg_WaitForGetOffsetInRange::ID) {
     // It's OK to post task that may never run even for sync messages, because
     // if the channel is destroyed, the client Send will fail.
     main_task_runner_->PostTask(FROM_HERE,
                                 base::Bind(&GpuChannel::HandleOutOfOrderMessage,
                                            gpu_channel_->AsWeakPtr(), message));
+  } else if (scheduler_) {
+    SequenceId sequence_id = route_sequences_[message.routing_id()];
+    if (sequence_id.is_null())
+      return MessageErrorHandler(message, "Invalid route");
+
+    std::vector<SyncToken> sync_token_fences;
+    if (message.type() == GpuCommandBufferMsg_AsyncFlush::ID) {
+      GpuCommandBufferMsg_AsyncFlush::Param params;
+      if (!GpuCommandBufferMsg_AsyncFlush::Read(&message, &params))
+        return MessageErrorHandler(message, "Invalid flush message");
+      sync_token_fences = std::get<3>(params);
+    }
+
+    scheduler_->ScheduleTask(sequence_id,
+                             base::BindOnce(&GpuChannel::HandleMessage,
+                                            gpu_channel_->AsWeakPtr(), message),
+                             sync_token_fences);
   } else {
     // Message queue takes care of PostTask.
     message_queue_->PushBackMessage(message);
   }
 
   return true;
 }
 
 bool GpuChannelMessageFilter::Send(IPC::Message* message) {
   return ipc_channel_->Send(message);
@@ skipping 11 matching lines @@
 }
 
 // Definitions for constructor and destructor of this interface are needed to
 // avoid MSVC LNK2019.
 FilteredSender::FilteredSender() = default;
 
 FilteredSender::~FilteredSender() = default;
 
 GpuChannel::GpuChannel(
     GpuChannelManager* gpu_channel_manager,
+    Scheduler* scheduler,
     SyncPointManager* sync_point_manager,
     GpuWatchdogThread* watchdog,
     scoped_refptr<gl::GLShareGroup> share_group,
     scoped_refptr<gles2::MailboxManager> mailbox_manager,
     scoped_refptr<PreemptionFlag> preempting_flag,
     scoped_refptr<PreemptionFlag> preempted_flag,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
     int32_t client_id,
     uint64_t client_tracing_id,
     bool is_gpu_host)
     : gpu_channel_manager_(gpu_channel_manager),
+      scheduler_(scheduler),
       sync_point_manager_(sync_point_manager),
       preempting_flag_(preempting_flag),
       preempted_flag_(preempted_flag),
       client_id_(client_id),
       client_tracing_id_(client_tracing_id),
       task_runner_(task_runner),
       io_task_runner_(io_task_runner),
       share_group_(share_group),
       mailbox_manager_(mailbox_manager),
       watchdog_(watchdog),
       is_gpu_host_(is_gpu_host),
       weak_factory_(this) {
-  DCHECK(gpu_channel_manager);
-  DCHECK(client_id);
+  DCHECK(gpu_channel_manager_);
+  DCHECK(client_id_);
 
-  message_queue_ = new GpuChannelMessageQueue(this, task_runner, io_task_runner,
-                                              preempting_flag, preempted_flag,
-                                              sync_point_manager);
+  if (!scheduler_) {
+    message_queue_ = new GpuChannelMessageQueue(
+        this, sync_point_manager->CreateSyncPointOrderData(), task_runner,
+        io_task_runner, preempting_flag, preempted_flag);
+  }
 
-  filter_ = new GpuChannelMessageFilter(this, message_queue_, task_runner);
+  filter_ =
+      new GpuChannelMessageFilter(this, scheduler, message_queue_, task_runner);
 }
 
 GpuChannel::~GpuChannel() {
   // Clear stubs first because of dependencies.
   stubs_.clear();
 
   // Destroy filter first so that no message queue gets no more messages.
   filter_->Destroy();
 
-  message_queue_->Destroy();
+  // Release IPC channel. This acts like a flag for any posted tasks.
+  channel_ = nullptr;
+
+  if (scheduler_) {
+    for (const auto& kv : stream_sequences_)
+      scheduler_->DestroySequence(kv.second);
+  } else {
+    message_queue_->Destroy();
+  }
 
   DCHECK(!preempting_flag_ || !preempting_flag_->IsSet());
 }
 
 void GpuChannel::Init(std::unique_ptr<FilteredSender> channel) {
   channel_ = std::move(channel);
   channel_->AddFilter(filter_.get());
 }
 
 void GpuChannel::SetUnhandledMessageListener(IPC::Listener* listener) {
@@ skipping 33 matching lines @@
 
   if (!channel_) {
     delete message;
     return false;
   }
 
   return channel_->Send(message);
 }
 
 void GpuChannel::OnCommandBufferScheduled(GpuCommandBufferStub* stub) {
-  message_queue_->SetScheduled(true);
-  // TODO(sunnyps): Enable gpu scheduler task queue for stub's sequence.
+  if (scheduler_) {
+    scheduler_->EnableSequence(stub->sequence_id());
+  } else {
+    message_queue_->SetScheduled(true);
+  }
 }
 
 void GpuChannel::OnCommandBufferDescheduled(GpuCommandBufferStub* stub) {
-  message_queue_->SetScheduled(false);
-  // TODO(sunnyps): Disable gpu scheduler task queue for stub's sequence.
+  if (scheduler_) {
+    scheduler_->DisableSequence(stub->sequence_id());
+  } else {
+    message_queue_->SetScheduled(false);
+  }
 }
 
 GpuCommandBufferStub* GpuChannel::LookupCommandBuffer(int32_t route_id) {
   auto it = stubs_.find(route_id);
   if (it == stubs_.end())
     return nullptr;
 
   return it->second.get();
 }
 
 void GpuChannel::LoseAllContexts() {
   gpu_channel_manager_->LoseAllContexts();
 }
 
 void GpuChannel::MarkAllContextsLost() {
   for (auto& kv : stubs_)
     kv.second->MarkContextLost();
 }
 
 bool GpuChannel::AddRoute(int32_t route_id,
                           SequenceId sequence_id,
                           IPC::Listener* listener) {
-  // TODO(sunnyps): Add route id to sequence id mapping to filter.
+  if (scheduler_)
+    filter_->AddRoute(route_id, sequence_id);
   return router_.AddRoute(route_id, listener);
 }
 
 void GpuChannel::RemoveRoute(int32_t route_id) {
+  if (scheduler_)
+    filter_->RemoveRoute(route_id);
   router_.RemoveRoute(route_id);
 }
 
 bool GpuChannel::OnControlMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuChannel, msg)
     IPC_MESSAGE_HANDLER(GpuChannelMsg_CreateCommandBuffer,
                         OnCreateCommandBuffer)
     IPC_MESSAGE_HANDLER(GpuChannelMsg_DestroyCommandBuffer,
                         OnDestroyCommandBuffer)
     IPC_MESSAGE_HANDLER(GpuChannelMsg_GetDriverBugWorkArounds,
                         OnGetDriverBugWorkArounds)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
+void GpuChannel::HandleMessage(const IPC::Message& msg) {
+  // Even if we're in the process of being destroyed, be sure to reply to sync
+  // messages.
+  if (!channel_) {
+    if (msg.is_sync()) {
+      IPC::Message* reply = IPC::SyncMessage::GenerateReply(&msg);
+      reply->set_reply_error();
+      Send(reply);

[piman, 2017/05/09 00:48:38]

nit: if channel_ is nullptr, Send won't do anything, so you can skip this (sync
messages should be unblock on the client side if this happens).

[sunnyps, 2017/05/10 23:15:15]

Done.

+    }
+    return;
+  }
+
+  int32_t routing_id = msg.routing_id();
+  GpuCommandBufferStub* stub = LookupCommandBuffer(routing_id);
+
+  DCHECK(!stub || stub->IsScheduled());
+
+  DVLOG(1) << "received message @" << &msg << " on channel @" << this
+           << " with type " << msg.type();
+
+  HandleMessageHelper(msg);
+
+  // If we get descheduled or yield while processing a message.
+  if (stub && (stub->HasUnprocessedCommands() || !stub->IsScheduled())) {
+    DCHECK((uint32_t)GpuCommandBufferMsg_AsyncFlush::ID == msg.type() ||
+           (uint32_t)GpuCommandBufferMsg_WaitSyncToken::ID == msg.type());
+    scheduler_->ContinueTask(
+        stub->sequence_id(),
+        base::BindOnce(&GpuChannel::HandleMessage, AsWeakPtr(), msg));
+  }
+}
+
 void GpuChannel::HandleMessageOnQueue() {
   const GpuChannelMessage* channel_msg =
       message_queue_->BeginMessageProcessing();
   if (!channel_msg)
     return;
 
   const IPC::Message& msg = channel_msg->message;
   int32_t routing_id = msg.routing_id();
   GpuCommandBufferStub* stub = LookupCommandBuffer(routing_id);
 
@@ skipping 72 matching lines @@
     *capabilities = gpu::Capabilities();
   }
 }
 
 std::unique_ptr<GpuCommandBufferStub> GpuChannel::CreateCommandBuffer(
     const GPUCreateCommandBufferConfig& init_params,
     int32_t route_id,
     std::unique_ptr<base::SharedMemory> shared_state_shm) {
   if (init_params.surface_handle != kNullSurfaceHandle && !is_gpu_host_) {
     DLOG(ERROR) << "GpuChannel::CreateCommandBuffer(): attempt to create a "
-                   "view context on a non-priviledged channel";
+                   "view context on a non-privileged channel";
     return nullptr;
   }
 
   int32_t share_group_id = init_params.share_group_id;
   GpuCommandBufferStub* share_group = LookupCommandBuffer(share_group_id);
 
   if (!share_group && share_group_id != MSG_ROUTING_NONE) {
     DLOG(ERROR) << "GpuChannel::CreateCommandBuffer(): invalid share group id";
     return nullptr;
   }
 
   int32_t stream_id = init_params.stream_id;
   if (share_group && stream_id != share_group->stream_id()) {
     DLOG(ERROR) << "GpuChannel::CreateCommandBuffer(): stream id does not "
                    "match share group stream id";
     return nullptr;
   }
 
   GpuStreamPriority stream_priority = init_params.stream_priority;
-  if (stream_priority == GpuStreamPriority::REAL_TIME && !is_gpu_host_) {
-    DLOG(ERROR) << "GpuChannel::CreateCommandBuffer(): real time stream "
-                   "priority not allowed";
+  if (stream_priority <= GpuStreamPriority::HIGH && !is_gpu_host_) {
+    DLOG(ERROR) << "GpuChannel::CreateCommandBuffer(): high priority stream "
+                   "not allowed on a non-privileged channel";
     return nullptr;
   }
 
   if (share_group && !share_group->decoder()) {
     // This should catch test errors where we did not Initialize the
     // share_group's CommandBuffer.
     DLOG(ERROR) << "GpuChannel::CreateCommandBuffer(): shared context was "
                    "not initialized";
     return nullptr;
   }
 
   if (share_group && share_group->decoder()->WasContextLost()) {
     DLOG(ERROR) << "GpuChannel::CreateCommandBuffer(): shared context was "
                    "already lost";
     return nullptr;
   }
 
   CommandBufferId command_buffer_id =
       GenerateCommandBufferId(client_id_, route_id);
 
-  // TODO(sunnyps): Lookup sequence id using stream id to sequence id map.
-  SequenceId sequence_id = message_queue_->sequence_id();
+  SequenceId sequence_id;
+  if (scheduler_) {
+    sequence_id = stream_sequences_[stream_id];
+    if (sequence_id.is_null()) {
+      sequence_id = scheduler_->CreateSequence(stream_priority);
+      stream_sequences_[stream_id] = sequence_id;
+    }
+  } else {
+    sequence_id = message_queue_->sequence_id();
+  }
 
   std::unique_ptr<GpuCommandBufferStub> stub(GpuCommandBufferStub::Create(
       this, share_group, init_params, command_buffer_id, sequence_id, stream_id,
       route_id, std::move(shared_state_shm)));
 
   if (!AddRoute(route_id, sequence_id, stub.get())) {
     DLOG(ERROR) << "GpuChannel::CreateCommandBuffer(): failed to add route";
     return nullptr;
   }
 
@@ skipping 89 matching lines @@
 
       return manager->gpu_memory_buffer_factory()
           ->AsImageFactory()
           ->CreateImageForGpuMemoryBuffer(handle, size, format, internalformat,
                                           client_id_, surface_handle);
     }
   }
 }
 
 }  // namespace gpu