gpu/command_buffer/client/cmd_buffer_helper_test.cc

   1 // Copyright (c) 2012 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 // Tests for the Command Buffer Helper.
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "gpu/command_buffer/client/cmd_buffer_helper.h"
  11 #include "gpu/command_buffer/service/command_buffer_service.h"
  12 #include "gpu/command_buffer/service/gpu_scheduler.h"
  13 #include "gpu/command_buffer/service/mocks.h"
  14 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16
  17 #if defined(OS_MACOSX)
  18 #include "base/mac/scoped_nsautorelease_pool.h"
  19 #endif
  20
  21 namespace gpu {
  22
  23 using testing::Return;
  24 using testing::Mock;
  25 using testing::Truly;
  26 using testing::Sequence;
  27 using testing::DoAll;
  28 using testing::Invoke;
  29 using testing::_;
  30
  31 const int32 kTotalNumCommandEntries = 10;
  32 const int32 kCommandBufferSizeBytes =
  33     kTotalNumCommandEntries * sizeof(CommandBufferEntry);
  34 const int32 kUnusedCommandId = 5;  // we use 0 and 2 currently.
  35
  36 // Test fixture for CommandBufferHelper test - Creates a CommandBufferHelper,
  37 // using a CommandBufferEngine with a mock AsyncAPIInterface for its interface
  38 // (calling it directly, not through the RPC mechanism).
  39 class CommandBufferHelperTest : public testing::Test {
  40  protected:
  41   virtual void SetUp() {
  42     api_mock_.reset(new AsyncAPIMock);
  43     // ignore noops in the mock - we don't want to inspect the internals of the
  44     // helper.
  45     EXPECT_CALL(*api_mock_, DoCommand(cmd::kNoop, _, _))
  46         .WillRepeatedly(Return(error::kNoError));
  47
  48     {
  49       TransferBufferManager* manager = new TransferBufferManager();
  50       transfer_buffer_manager_.reset(manager);
  51       EXPECT_TRUE(manager->Initialize());
  52     }
  53     command_buffer_.reset(
  54         new CommandBufferService(transfer_buffer_manager_.get()));
  55     EXPECT_TRUE(command_buffer_->Initialize());
  56
  57     gpu_scheduler_.reset(new GpuScheduler(
  58         command_buffer_.get(), api_mock_.get(), NULL));
  59     command_buffer_->SetPutOffsetChangeCallback(base::Bind(
  60         &GpuScheduler::PutChanged, base::Unretained(gpu_scheduler_.get())));
  61     command_buffer_->SetGetBufferChangeCallback(base::Bind(
  62         &GpuScheduler::SetGetBuffer, base::Unretained(gpu_scheduler_.get())));
  63
  64     api_mock_->set_engine(gpu_scheduler_.get());
  65
  66     helper_.reset(new CommandBufferHelper(command_buffer_.get()));
  67     helper_->Initialize(kCommandBufferSizeBytes);
  68   }
  69
  70   virtual void TearDown() {
  71     // If the GpuScheduler posts any tasks, this forces them to run.
  72     base::MessageLoop::current()->RunUntilIdle();
  73   }
  74
  75   const CommandParser* GetParser() const {
  76     return gpu_scheduler_->parser();
  77   }
  78
  79   // Adds a command to the buffer through the helper, while adding it as an
  80   // expected call on the API mock.
  81   void AddCommandWithExpect(error::Error _return,
  82                             unsigned int command,
  83                             int arg_count,
  84                             CommandBufferEntry *args) {
  85     CommandHeader header;
  86     header.size = arg_count + 1;
  87     header.command = command;
  88     CommandBufferEntry* cmds = helper_->GetSpace(arg_count + 1);
  89     CommandBufferOffset put = 0;
  90     cmds[put++].value_header = header;
  91     for (int ii = 0; ii < arg_count; ++ii) {
  92       cmds[put++] = args[ii];
  93     }
  94
  95     EXPECT_CALL(*api_mock_, DoCommand(command, arg_count,
  96         Truly(AsyncAPIMock::IsArgs(arg_count, args))))
  97         .InSequence(sequence_)
  98         .WillOnce(Return(_return));
  99   }
 100
 101   // Checks that the buffer from put to put+size is free in the parser.
 102   void CheckFreeSpace(CommandBufferOffset put, unsigned int size) {
 103     CommandBufferOffset parser_put = GetParser()->put();
 104     CommandBufferOffset parser_get = GetParser()->get();
 105     CommandBufferOffset limit = put + size;
 106     if (parser_get > parser_put) {
 107       // "busy" buffer wraps, so "free" buffer is between put (inclusive) and
 108       // get (exclusive).
 109       EXPECT_LE(parser_put, put);
 110       EXPECT_GT(parser_get, limit);
 111     } else {
 112       // "busy" buffer does not wrap, so the "free" buffer is the top side (from
 113       // put to the limit) and the bottom side (from 0 to get).
 114       if (put >= parser_put) {
 115         // we're on the top side, check we are below the limit.
 116         EXPECT_GE(kTotalNumCommandEntries, limit);
 117       } else {
 118         // we're on the bottom side, check we are below get.
 119         EXPECT_GT(parser_get, limit);
 120       }
 121     }
 122   }
 123
 124   int32 GetGetOffset() {
 125     return command_buffer_->GetState().get_offset;
 126   }
 127
 128   int32 GetPutOffset() {
 129     return command_buffer_->GetState().put_offset;
 130   }
 131
 132   error::Error GetError() {
 133     return command_buffer_->GetState().error;
 134   }
 135
 136   CommandBufferOffset get_helper_put() { return helper_->put_; }
 137
 138 #if defined(OS_MACOSX)
 139   base::mac::ScopedNSAutoreleasePool autorelease_pool_;
 140 #endif
 141   base::MessageLoop message_loop_;
 142   scoped_ptr<AsyncAPIMock> api_mock_;
 143   scoped_ptr<TransferBufferManagerInterface> transfer_buffer_manager_;
 144   scoped_ptr<CommandBufferService> command_buffer_;
 145   scoped_ptr<GpuScheduler> gpu_scheduler_;
 146   scoped_ptr<CommandBufferHelper> helper_;
 147   Sequence sequence_;
 148 };
 149
 150 // Checks that commands in the buffer are properly executed, and that the
 151 // status/error stay valid.
 152 TEST_F(CommandBufferHelperTest, TestCommandProcessing) {
 153   // Check initial state of the engine - it should have been configured by the
 154   // helper.
 155   EXPECT_TRUE(GetParser() != NULL);
 156   EXPECT_EQ(error::kNoError, GetError());
 157   EXPECT_EQ(0, GetGetOffset());
 158
 159   // Add 3 commands through the helper
 160   AddCommandWithExpect(error::kNoError, kUnusedCommandId, 0, NULL);
 161
 162   CommandBufferEntry args1[2];
 163   args1[0].value_uint32 = 3;
 164   args1[1].value_float = 4.f;
 165   AddCommandWithExpect(error::kNoError, kUnusedCommandId, 2, args1);
 166
 167   CommandBufferEntry args2[2];
 168   args2[0].value_uint32 = 5;
 169   args2[1].value_float = 6.f;
 170   AddCommandWithExpect(error::kNoError, kUnusedCommandId, 2, args2);
 171
 172   // Wait until it's done.
 173   helper_->Finish();
 174   // Check that the engine has no more work to do.
 175   EXPECT_TRUE(GetParser()->IsEmpty());
 176
 177   // Check that the commands did happen.
 178   Mock::VerifyAndClearExpectations(api_mock_.get());
 179
 180   // Check the error status.
 181   EXPECT_EQ(error::kNoError, GetError());
 182 }
 183
 184 // Checks that commands in the buffer are properly executed when wrapping the
 185 // buffer, and that the status/error stay valid.
 186 TEST_F(CommandBufferHelperTest, TestCommandWrapping) {
 187   // Add 5 commands of size 3 through the helper to make sure we do wrap.
 188   CommandBufferEntry args1[2];
 189   args1[0].value_uint32 = 5;
 190   args1[1].value_float = 4.f;
 191
 192   for (unsigned int i = 0; i < 5; ++i) {
 193     AddCommandWithExpect(error::kNoError, kUnusedCommandId + i, 2, args1);
 194   }
 195
 196   helper_->Finish();
 197   // Check that the commands did happen.
 198   Mock::VerifyAndClearExpectations(api_mock_.get());
 199
 200   // Check the error status.
 201   EXPECT_EQ(error::kNoError, GetError());
 202 }
 203
 204 // Checks the case where the command inserted exactly matches the space left in
 205 // the command buffer.
 206 TEST_F(CommandBufferHelperTest, TestCommandWrappingExactMultiple) {
 207   const int32 kCommandSize = 5;
 208   const size_t kNumArgs = kCommandSize - 1;
 209   COMPILE_ASSERT(kTotalNumCommandEntries % kCommandSize == 0,
 210                  Not_multiple_of_num_command_entries);
 211   CommandBufferEntry args1[kNumArgs];
 212   for (size_t ii = 0; ii < kNumArgs; ++ii) {
 213     args1[0].value_uint32 = ii + 1;
 214   }
 215
 216   for (unsigned int i = 0; i < 5; ++i) {
 217     AddCommandWithExpect(
 218         error::kNoError, i + kUnusedCommandId, kNumArgs, args1);
 219   }
 220
 221   helper_->Finish();
 222   // Check that the commands did happen.
 223   Mock::VerifyAndClearExpectations(api_mock_.get());
 224
 225   // Check the error status.
 226   EXPECT_EQ(error::kNoError, GetError());
 227 }
 228
 229 // Checks that asking for available entries work, and that the parser
 230 // effectively won't use that space.
 231 TEST_F(CommandBufferHelperTest, TestAvailableEntries) {
 232   CommandBufferEntry args[2];
 233   args[0].value_uint32 = 3;
 234   args[1].value_float = 4.f;
 235
 236   // Add 2 commands through the helper - 8 entries
 237   AddCommandWithExpect(error::kNoError, kUnusedCommandId + 1, 0, NULL);
 238   AddCommandWithExpect(error::kNoError, kUnusedCommandId + 2, 0, NULL);
 239   AddCommandWithExpect(error::kNoError, kUnusedCommandId + 3, 2, args);
 240   AddCommandWithExpect(error::kNoError, kUnusedCommandId + 4, 2, args);
 241
 242   // Ask for 5 entries.
 243   helper_->WaitForAvailableEntries(5);
 244
 245   CommandBufferOffset put = get_helper_put();
 246   CheckFreeSpace(put, 5);
 247
 248   // Add more commands.
 249   AddCommandWithExpect(error::kNoError, kUnusedCommandId + 5, 2, args);
 250
 251   // Wait until everything is done done.
 252   helper_->Finish();
 253
 254   // Check that the commands did happen.
 255   Mock::VerifyAndClearExpectations(api_mock_.get());
 256
 257   // Check the error status.
 258   EXPECT_EQ(error::kNoError, GetError());
 259 }
 260
 261 // Checks that the InsertToken/WaitForToken work.
 262 TEST_F(CommandBufferHelperTest, TestToken) {
 263   CommandBufferEntry args[2];
 264   args[0].value_uint32 = 3;
 265   args[1].value_float = 4.f;
 266
 267   // Add a first command.
 268   AddCommandWithExpect(error::kNoError, kUnusedCommandId + 3, 2, args);
 269   // keep track of the buffer position.
 270   CommandBufferOffset command1_put = get_helper_put();
 271   int32 token = helper_->InsertToken();
 272
 273   EXPECT_CALL(*api_mock_.get(), DoCommand(cmd::kSetToken, 1, _))
 274       .WillOnce(DoAll(Invoke(api_mock_.get(), &AsyncAPIMock::SetToken),
 275                       Return(error::kNoError)));
 276   // Add another command.
 277   AddCommandWithExpect(error::kNoError, kUnusedCommandId + 4, 2, args);
 278   helper_->WaitForToken(token);
 279   // check that the get pointer is beyond the first command.
 280   EXPECT_LE(command1_put, GetGetOffset());
 281   helper_->Finish();
 282
 283   // Check that the commands did happen.
 284   Mock::VerifyAndClearExpectations(api_mock_.get());
 285
 286   // Check the error status.
 287   EXPECT_EQ(error::kNoError, GetError());
 288 }
 289
 290 TEST_F(CommandBufferHelperTest, FreeRingBuffer) {
 291   EXPECT_TRUE(helper_->HaveRingBuffer());
 292
 293   // Test freeing ring buffer.
 294   helper_->FreeRingBuffer();
 295   EXPECT_FALSE(helper_->HaveRingBuffer());
 296
 297   // Test that InsertToken allocates a new one
 298   int32 token = helper_->InsertToken();
 299   EXPECT_TRUE(helper_->HaveRingBuffer());
 300   EXPECT_CALL(*api_mock_.get(), DoCommand(cmd::kSetToken, 1, _))
 301       .WillOnce(DoAll(Invoke(api_mock_.get(), &AsyncAPIMock::SetToken),
 302                       Return(error::kNoError)));
 303   helper_->WaitForToken(token);
 304   helper_->FreeRingBuffer();
 305   EXPECT_FALSE(helper_->HaveRingBuffer());
 306
 307   // Test that WaitForAvailableEntries allocates a new one
 308   AddCommandWithExpect(error::kNoError, kUnusedCommandId, 0, NULL);
 309   EXPECT_TRUE(helper_->HaveRingBuffer());
 310   helper_->Finish();
 311   helper_->FreeRingBuffer();
 312   EXPECT_FALSE(helper_->HaveRingBuffer());
 313
 314   // Check that the commands did happen.
 315   Mock::VerifyAndClearExpectations(api_mock_.get());
 316 }
 317
 318 TEST_F(CommandBufferHelperTest, Noop) {
 319   for (int ii = 1; ii < 4; ++ii) {
 320     CommandBufferOffset put_before = get_helper_put();
 321     helper_->Noop(ii);
 322     CommandBufferOffset put_after = get_helper_put();
 323     EXPECT_EQ(ii, put_after - put_before);
 324   }
 325 }
 326
 327 TEST_F(CommandBufferHelperTest, IsContextLost) {
 328   EXPECT_FALSE(helper_->IsContextLost());
 329   command_buffer_->SetParseError(error::kGenericError);
 330   EXPECT_TRUE(helper_->IsContextLost());
 331 }
 332
 333 }  // namespace gpu