src/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 "base/message_loop/message_loop.h"
   6 #include "gpu/command_buffer/common/command_buffer_mock.h"
   7 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
   8 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
   9 #include "gpu/command_buffer/service/gpu_scheduler.h"
  10 #include "gpu/command_buffer/service/mocks.h"
  11 #include "testing/gmock/include/gmock/gmock.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 #if defined(OS_MACOSX)
  15 #include "base/mac/scoped_nsautorelease_pool.h"
  16 #endif
  17
  18 using testing::_;
  19 using testing::DoAll;
  20 using testing::Invoke;
  21 using testing::NiceMock;
  22 using testing::Return;
  23 using testing::SetArgumentPointee;
  24 using testing::StrictMock;
  25
  26 namespace gpu {
  27
  28 const size_t kRingBufferSize = 1024;
  29 const size_t kRingBufferEntries = kRingBufferSize / sizeof(CommandBufferEntry);
  30
  31 class GpuSchedulerTest : public testing::Test {
  32  protected:
  33   static const int32 kTransferBufferId = 123;
  34
  35   virtual void SetUp() {
  36     shared_memory_.reset(new ::base::SharedMemory);
  37     shared_memory_->CreateAndMapAnonymous(kRingBufferSize);
  38     buffer_ = static_cast<int32*>(shared_memory_->memory());
  39     shared_memory_buffer_.ptr = buffer_;
  40     shared_memory_buffer_.size = kRingBufferSize;
  41     memset(buffer_, 0, kRingBufferSize);
  42
  43     command_buffer_.reset(new MockCommandBuffer);
  44
  45     CommandBuffer::State default_state;
  46     default_state.num_entries = kRingBufferEntries;
  47     ON_CALL(*command_buffer_.get(), GetState())
  48         .WillByDefault(Return(default_state));
  49
  50     decoder_.reset(new gles2::MockGLES2Decoder());
  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   virtual void TearDown() {
  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_->GetState().error;
  68   }
  69
  70 #if defined(OS_MACOSX)
  71   base::mac::ScopedNSAutoreleasePool autorelease_pool_;
  72 #endif
  73   base::MessageLoop message_loop;
  74   scoped_ptr<MockCommandBuffer> command_buffer_;
  75   scoped_ptr<base::SharedMemory> shared_memory_;
  76   Buffer shared_memory_buffer_;
  77   int32* buffer_;
  78   scoped_ptr<gles2::MockGLES2Decoder> decoder_;
  79   scoped_ptr<GpuScheduler> scheduler_;
  80 };
  81
  82 TEST_F(GpuSchedulerTest, SchedulerDoesNothingIfRingBufferIsEmpty) {
  83   CommandBuffer::State state;
  84
  85   state.put_offset = 0;
  86   EXPECT_CALL(*command_buffer_, GetState())
  87     .WillRepeatedly(Return(state));
  88
  89   EXPECT_CALL(*command_buffer_, SetParseError(_))
  90     .Times(0);
  91
  92   scheduler_->PutChanged();
  93 }
  94
  95 TEST_F(GpuSchedulerTest, GetSetBuffer) {
  96   CommandBuffer::State state;
  97
  98   // Set the get offset to something not 0.
  99   EXPECT_CALL(*command_buffer_, SetGetOffset(2));
 100   scheduler_->SetGetOffset(2);
 101   EXPECT_EQ(2, scheduler_->GetGetOffset());
 102
 103   // Set the buffer.
 104   EXPECT_CALL(*command_buffer_, GetTransferBuffer(kTransferBufferId))
 105      .WillOnce(Return(shared_memory_buffer_));
 106   EXPECT_CALL(*command_buffer_, SetGetOffset(0));
 107   EXPECT_TRUE(scheduler_->SetGetBuffer(kTransferBufferId));
 108
 109   // Check the get offset was reset.
 110   EXPECT_EQ(0, scheduler_->GetGetOffset());
 111 }
 112
 113 TEST_F(GpuSchedulerTest, ProcessesOneCommand) {
 114   CommandHeader* header = reinterpret_cast<CommandHeader*>(&buffer_[0]);
 115   header[0].command = 7;
 116   header[0].size = 2;
 117   buffer_[1] = 123;
 118
 119   CommandBuffer::State state;
 120
 121   state.put_offset = 2;
 122   EXPECT_CALL(*command_buffer_, GetState())
 123     .WillRepeatedly(Return(state));
 124   EXPECT_CALL(*command_buffer_, SetGetOffset(2));
 125
 126   EXPECT_CALL(*decoder_, DoCommand(7, 1, &buffer_[0]))
 127     .WillOnce(Return(error::kNoError));
 128
 129   EXPECT_CALL(*command_buffer_, SetParseError(_))
 130     .Times(0);
 131
 132   scheduler_->PutChanged();
 133 }
 134
 135 TEST_F(GpuSchedulerTest, ProcessesTwoCommands) {
 136   CommandHeader* header = reinterpret_cast<CommandHeader*>(&buffer_[0]);
 137   header[0].command = 7;
 138   header[0].size = 2;
 139   buffer_[1] = 123;
 140   header[2].command = 8;
 141   header[2].size = 1;
 142
 143   CommandBuffer::State state;
 144
 145   state.put_offset = 3;
 146   EXPECT_CALL(*command_buffer_, GetState())
 147     .WillRepeatedly(Return(state));
 148
 149   EXPECT_CALL(*decoder_, DoCommand(7, 1, &buffer_[0]))
 150     .WillOnce(Return(error::kNoError));
 151   EXPECT_CALL(*command_buffer_, SetGetOffset(2));
 152
 153   EXPECT_CALL(*decoder_, DoCommand(8, 0, &buffer_[2]))
 154     .WillOnce(Return(error::kNoError));
 155   EXPECT_CALL(*command_buffer_, SetGetOffset(3));
 156
 157   scheduler_->PutChanged();
 158 }
 159
 160 TEST_F(GpuSchedulerTest, SetsErrorCodeOnCommandBuffer) {
 161   CommandHeader* header = reinterpret_cast<CommandHeader*>(&buffer_[0]);
 162   header[0].command = 7;
 163   header[0].size = 1;
 164
 165   CommandBuffer::State state;
 166
 167   state.put_offset = 1;
 168   EXPECT_CALL(*command_buffer_, GetState())
 169     .WillRepeatedly(Return(state));
 170
 171   EXPECT_CALL(*decoder_, DoCommand(7, 0, &buffer_[0]))
 172     .WillOnce(Return(
 173         error::kUnknownCommand));
 174   EXPECT_CALL(*command_buffer_, SetGetOffset(1));
 175
 176   EXPECT_CALL(*command_buffer_, SetContextLostReason(_));
 177   EXPECT_CALL(*decoder_, GetContextLostReason())
 178     .WillOnce(Return(error::kUnknown));
 179   EXPECT_CALL(*command_buffer_,
 180       SetParseError(error::kUnknownCommand));
 181
 182   scheduler_->PutChanged();
 183 }
 184
 185 TEST_F(GpuSchedulerTest, ProcessCommandsDoesNothingAfterError) {
 186   CommandBuffer::State state;
 187   state.error = error::kGenericError;
 188
 189   EXPECT_CALL(*command_buffer_, GetState())
 190     .WillRepeatedly(Return(state));
 191
 192   scheduler_->PutChanged();
 193 }
 194
 195 TEST_F(GpuSchedulerTest, CanGetAddressOfSharedMemory) {
 196   EXPECT_CALL(*command_buffer_.get(), GetTransferBuffer(7))
 197     .WillOnce(Return(shared_memory_buffer_));
 198
 199   EXPECT_EQ(&buffer_[0], scheduler_->GetSharedMemoryBuffer(7).ptr);
 200 }
 201
 202 ACTION_P2(SetPointee, address, value) {
 203   *address = value;
 204 }
 205
 206 TEST_F(GpuSchedulerTest, CanGetSizeOfSharedMemory) {
 207   EXPECT_CALL(*command_buffer_.get(), GetTransferBuffer(7))
 208     .WillOnce(Return(shared_memory_buffer_));
 209
 210   EXPECT_EQ(kRingBufferSize, scheduler_->GetSharedMemoryBuffer(7).size);
 211 }
 212
 213 TEST_F(GpuSchedulerTest, SetTokenForwardsToCommandBuffer) {
 214   EXPECT_CALL(*command_buffer_, SetToken(7));
 215   scheduler_->set_token(7);
 216 }
 217
 218 }  // namespace gpu