gpu/command_buffer/service/gpu_scheduler_unittest.cc

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "gpu/command_buffer/common/command_buffer_mock.h"
   6 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
   7 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
   8 #include "gpu/command_buffer/service/gpu_scheduler.h"
   9 #include "gpu/command_buffer/service/mocks.h"
  10 #include "testing/gmock/include/gmock/gmock.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12
  13 using testing::_;
  14 using testing::DoAll;
  15 using testing::Invoke;
  16 using testing::NiceMock;
  17 using testing::Return;
  18 using testing::SetArgumentPointee;
  19 using testing::StrictMock;
  20
  21 namespace gpu {
  22
  23 const size_t kRingBufferSize = 1024;
  24
  25 class GpuSchedulerTest : public testing::Test {
  26  protected:
  27   static const int32 kTransferBufferId = 123;
  28
  29   void SetUp() override {
  30     scoped_ptr<base::SharedMemory> shared_memory(new ::base::SharedMemory);
  31     shared_memory->CreateAndMapAnonymous(kRingBufferSize);
  32     buffer_ = static_cast<int32*>(shared_memory->memory());
  33     shared_memory_buffer_ =
  34         MakeBufferFromSharedMemory(shared_memory.Pass(), kRingBufferSize);
  35     memset(buffer_, 0, kRingBufferSize);
  36
  37     command_buffer_.reset(new MockCommandBuffer);
  38
  39     CommandBuffer::State default_state;
  40     ON_CALL(*command_buffer_.get(), GetLastState())
  41         .WillByDefault(Return(default_state));
  42     ON_CALL(*command_buffer_.get(), GetPutOffset())
  43         .WillByDefault(Return(0));
  44
  45     decoder_.reset(new gles2::MockGLES2Decoder());
  46     // Install FakeDoCommands handler so we can use individual DoCommand()
  47     // expectations.
  48     EXPECT_CALL(*decoder_, DoCommands(_, _, _, _)).WillRepeatedly(
  49         Invoke(decoder_.get(), &gles2::MockGLES2Decoder::FakeDoCommands));
  50
  51     scheduler_.reset(new gpu::GpuScheduler(command_buffer_.get(),
  52                                            decoder_.get(),
  53                                            decoder_.get()));
  54     EXPECT_CALL(*command_buffer_, GetTransferBuffer(kTransferBufferId))
  55        .WillOnce(Return(shared_memory_buffer_));
  56     EXPECT_CALL(*command_buffer_, SetGetOffset(0));
  57     EXPECT_TRUE(scheduler_->SetGetBuffer(kTransferBufferId));
  58   }
  59
  60   void TearDown() override {
  61     // Ensure that any unexpected tasks posted by the GPU scheduler are executed
  62     // in order to fail the test.
  63     base::MessageLoop::current()->RunUntilIdle();
  64   }
  65
  66   error::Error GetError() {
  67     return command_buffer_->GetLastState().error;
  68   }
  69
  70   scoped_ptr<MockCommandBuffer> command_buffer_;
  71   scoped_refptr<Buffer> shared_memory_buffer_;
  72   int32* buffer_;
  73   scoped_ptr<gles2::MockGLES2Decoder> decoder_;
  74   scoped_ptr<GpuScheduler> scheduler_;
  75 };
  76
  77 TEST_F(GpuSchedulerTest, SchedulerDoesNothingIfRingBufferIsEmpty) {
  78   CommandBuffer::State state;
  79
  80   EXPECT_CALL(*command_buffer_, GetLastState())
  81     .WillRepeatedly(Return(state));
  82
  83   EXPECT_CALL(*command_buffer_, SetParseError(_))
  84     .Times(0);
  85
  86   scheduler_->PutChanged();
  87 }
  88
  89 TEST_F(GpuSchedulerTest, GetSetBuffer) {
  90   CommandBuffer::State state;
  91
  92   // Set the get offset to something not 0.
  93   EXPECT_CALL(*command_buffer_, SetGetOffset(2));
  94   scheduler_->SetGetOffset(2);
  95   EXPECT_EQ(2, scheduler_->GetGetOffset());
  96
  97   // Set the buffer.
  98   EXPECT_CALL(*command_buffer_, GetTransferBuffer(kTransferBufferId))
  99      .WillOnce(Return(shared_memory_buffer_));
 100   EXPECT_CALL(*command_buffer_, SetGetOffset(0));
 101   EXPECT_TRUE(scheduler_->SetGetBuffer(kTransferBufferId));
 102
 103   // Check the get offset was reset.
 104   EXPECT_EQ(0, scheduler_->GetGetOffset());
 105 }
 106
 107 TEST_F(GpuSchedulerTest, ProcessesOneCommand) {
 108   CommandHeader* header = reinterpret_cast<CommandHeader*>(&buffer_[0]);
 109   header[0].command = 7;
 110   header[0].size = 2;
 111   buffer_[1] = 123;
 112
 113   CommandBuffer::State state;
 114
 115   EXPECT_CALL(*command_buffer_, GetLastState())
 116     .WillRepeatedly(Return(state));
 117   EXPECT_CALL(*command_buffer_, GetPutOffset())
 118     .WillRepeatedly(Return(2));
 119   EXPECT_CALL(*command_buffer_, SetGetOffset(2));
 120
 121   EXPECT_CALL(*decoder_, DoCommand(7, 1, &buffer_[0]))
 122     .WillOnce(Return(error::kNoError));
 123
 124   EXPECT_CALL(*command_buffer_, SetParseError(_))
 125     .Times(0);
 126
 127   scheduler_->PutChanged();
 128 }
 129
 130 TEST_F(GpuSchedulerTest, ProcessesTwoCommands) {
 131   CommandHeader* header = reinterpret_cast<CommandHeader*>(&buffer_[0]);
 132   header[0].command = 7;
 133   header[0].size = 2;
 134   buffer_[1] = 123;
 135   header[2].command = 8;
 136   header[2].size = 1;
 137
 138   CommandBuffer::State state;
 139
 140   EXPECT_CALL(*command_buffer_, GetLastState())
 141     .WillRepeatedly(Return(state));
 142   EXPECT_CALL(*command_buffer_, GetPutOffset())
 143     .WillRepeatedly(Return(3));
 144
 145   EXPECT_CALL(*decoder_, DoCommand(7, 1, &buffer_[0]))
 146     .WillOnce(Return(error::kNoError));
 147
 148   EXPECT_CALL(*decoder_, DoCommand(8, 0, &buffer_[2]))
 149     .WillOnce(Return(error::kNoError));
 150   EXPECT_CALL(*command_buffer_, SetGetOffset(3));
 151
 152   scheduler_->PutChanged();
 153 }
 154
 155 TEST_F(GpuSchedulerTest, SetsErrorCodeOnCommandBuffer) {
 156   CommandHeader* header = reinterpret_cast<CommandHeader*>(&buffer_[0]);
 157   header[0].command = 7;
 158   header[0].size = 1;
 159
 160   CommandBuffer::State state;
 161
 162   EXPECT_CALL(*command_buffer_, GetLastState())
 163     .WillRepeatedly(Return(state));
 164   EXPECT_CALL(*command_buffer_, GetPutOffset())
 165     .WillRepeatedly(Return(1));
 166
 167   EXPECT_CALL(*decoder_, DoCommand(7, 0, &buffer_[0]))
 168     .WillOnce(Return(
 169         error::kUnknownCommand));
 170   EXPECT_CALL(*command_buffer_, SetGetOffset(1));
 171
 172   EXPECT_CALL(*command_buffer_, SetContextLostReason(_));
 173   EXPECT_CALL(*decoder_, GetContextLostReason())
 174     .WillOnce(Return(error::kUnknown));
 175   EXPECT_CALL(*command_buffer_,
 176       SetParseError(error::kUnknownCommand));
 177
 178   scheduler_->PutChanged();
 179 }
 180
 181 TEST_F(GpuSchedulerTest, ProcessCommandsDoesNothingAfterError) {
 182   CommandBuffer::State state;
 183   state.error = error::kGenericError;
 184
 185   EXPECT_CALL(*command_buffer_, GetLastState())
 186     .WillRepeatedly(Return(state));
 187
 188   scheduler_->PutChanged();
 189 }
 190
 191 TEST_F(GpuSchedulerTest, CanGetAddressOfSharedMemory) {
 192   EXPECT_CALL(*command_buffer_.get(), GetTransferBuffer(7))
 193     .WillOnce(Return(shared_memory_buffer_));
 194
 195   EXPECT_EQ(&buffer_[0], scheduler_->GetSharedMemoryBuffer(7)->memory());
 196 }
 197
 198 ACTION_P2(SetPointee, address, value) {
 199   *address = value;
 200 }
 201
 202 TEST_F(GpuSchedulerTest, CanGetSizeOfSharedMemory) {
 203   EXPECT_CALL(*command_buffer_.get(), GetTransferBuffer(7))
 204     .WillOnce(Return(shared_memory_buffer_));
 205
 206   EXPECT_EQ(kRingBufferSize, scheduler_->GetSharedMemoryBuffer(7)->size());
 207 }
 208
 209 TEST_F(GpuSchedulerTest, SetTokenForwardsToCommandBuffer) {
 210   EXPECT_CALL(*command_buffer_, SetToken(7));
 211   scheduler_->set_token(7);
 212 }
 213
 214 }  // namespace gpu