Home | History | Annotate | Download | only in client 
      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 // This file contains the tests for the RingBuffer class.
      6 
      7 #include "gpu/command_buffer/client/ring_buffer.h"
      8 
      9 #include "base/bind.h"
     10 #include "base/bind_helpers.h"
     11 #include "base/message_loop/message_loop.h"
     12 #include "gpu/command_buffer/client/cmd_buffer_helper.h"
     13 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
     14 #include "gpu/command_buffer/service/command_buffer_service.h"
     15 #include "gpu/command_buffer/service/gpu_scheduler.h"
     16 #include "gpu/command_buffer/service/mocks.h"
     17 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
     18 #include "testing/gtest/include/gtest/gtest.h"
     19 
     20 #if defined(OS_MACOSX)
     21 #include "base/mac/scoped_nsautorelease_pool.h"
     22 #endif
     23 
     24 namespace gpu {
     25 
     26 using testing::Return;
     27 using testing::Mock;
     28 using testing::Truly;
     29 using testing::Sequence;
     30 using testing::DoAll;
     31 using testing::Invoke;
     32 using testing::_;
     33 
     34 class BaseRingBufferTest : public testing::Test {
     35  protected:
     36   static const unsigned int kBaseOffset = 128;
     37   static const unsigned int kBufferSize = 1024;
     38 
     39   void RunPendingSetToken() {
     40     for (std::vector<const void*>::iterator it = set_token_arguments_.begin();
     41          it != set_token_arguments_.end();
     42          ++it) {
     43       api_mock_->SetToken(cmd::kSetToken, 1, *it);
     44     }
     45     set_token_arguments_.clear();
     46     delay_set_token_ = false;
     47   }
     48 
     49   void SetToken(unsigned int command,
     50                 unsigned int arg_count,
     51                 const void* _args) {
     52     EXPECT_EQ(static_cast<unsigned int>(cmd::kSetToken), command);
     53     EXPECT_EQ(1u, arg_count);
     54     if (delay_set_token_)
     55       set_token_arguments_.push_back(_args);
     56     else
     57       api_mock_->SetToken(cmd::kSetToken, 1, _args);
     58   }
     59 
     60   virtual void SetUp() {
     61     delay_set_token_ = false;
     62     api_mock_.reset(new AsyncAPIMock);
     63     // ignore noops in the mock - we don't want to inspect the internals of the
     64     // helper.
     65     EXPECT_CALL(*api_mock_, DoCommand(cmd::kNoop, 0, _))
     66         .WillRepeatedly(Return(error::kNoError));
     67     // Forward the SetToken calls to the engine
     68     EXPECT_CALL(*api_mock_.get(), DoCommand(cmd::kSetToken, 1, _))
     69         .WillRepeatedly(DoAll(Invoke(this, &BaseRingBufferTest::SetToken),
     70                               Return(error::kNoError)));
     71 
     72     {
     73       TransferBufferManager* manager = new TransferBufferManager();
     74       transfer_buffer_manager_.reset(manager);
     75       EXPECT_TRUE(manager->Initialize());
     76     }
     77     command_buffer_.reset(
     78         new CommandBufferService(transfer_buffer_manager_.get()));
     79     EXPECT_TRUE(command_buffer_->Initialize());
     80 
     81     gpu_scheduler_.reset(new GpuScheduler(
     82         command_buffer_.get(), api_mock_.get(), NULL));
     83     command_buffer_->SetPutOffsetChangeCallback(base::Bind(
     84         &GpuScheduler::PutChanged, base::Unretained(gpu_scheduler_.get())));
     85     command_buffer_->SetGetBufferChangeCallback(base::Bind(
     86         &GpuScheduler::SetGetBuffer, base::Unretained(gpu_scheduler_.get())));
     87 
     88     api_mock_->set_engine(gpu_scheduler_.get());
     89 
     90     helper_.reset(new CommandBufferHelper(command_buffer_.get()));
     91     helper_->Initialize(kBufferSize);
     92   }
     93 
     94   int32 GetToken() {
     95     return command_buffer_->GetState().token;
     96   }
     97 
     98 #if defined(OS_MACOSX)
     99   base::mac::ScopedNSAutoreleasePool autorelease_pool_;
    100 #endif
    101   base::MessageLoop message_loop_;
    102   scoped_ptr<AsyncAPIMock> api_mock_;
    103   scoped_ptr<TransferBufferManagerInterface> transfer_buffer_manager_;
    104   scoped_ptr<CommandBufferService> command_buffer_;
    105   scoped_ptr<GpuScheduler> gpu_scheduler_;
    106   scoped_ptr<CommandBufferHelper> helper_;
    107   std::vector<const void*> set_token_arguments_;
    108   bool delay_set_token_;
    109 
    110 };
    111 
    112 #ifndef _MSC_VER
    113 const unsigned int BaseRingBufferTest::kBaseOffset;
    114 const unsigned int BaseRingBufferTest::kBufferSize;
    115 #endif
    116 
    117 // Test fixture for RingBuffer test - Creates a RingBuffer, using a
    118 // CommandBufferHelper with a mock AsyncAPIInterface for its interface (calling
    119 // it directly, not through the RPC mechanism), making sure Noops are ignored
    120 // and SetToken are properly forwarded to the engine.
    121 class RingBufferTest : public BaseRingBufferTest {
    122  protected:
    123   virtual void SetUp() {
    124     BaseRingBufferTest::SetUp();
    125     allocator_.reset(new RingBuffer(kBaseOffset, kBufferSize, helper_.get()));
    126   }
    127 
    128   virtual void TearDown() {
    129     // If the GpuScheduler posts any tasks, this forces them to run.
    130     base::MessageLoop::current()->RunUntilIdle();
    131 
    132     BaseRingBufferTest::TearDown();
    133   }
    134 
    135   scoped_ptr<RingBuffer> allocator_;
    136 };
    137 
    138 // Checks basic alloc and free.
    139 TEST_F(RingBufferTest, TestBasic) {
    140   const unsigned int kSize = 16;
    141   EXPECT_EQ(kBufferSize, allocator_->GetLargestFreeOrPendingSize());
    142   EXPECT_EQ(kBufferSize, allocator_->GetLargestFreeSizeNoWaiting());
    143   RingBuffer::Offset offset = allocator_->Alloc(kSize);
    144   EXPECT_GE(kBufferSize, offset - kBaseOffset + kSize);
    145   EXPECT_EQ(kBufferSize, allocator_->GetLargestFreeOrPendingSize());
    146   EXPECT_EQ(kBufferSize - kSize, allocator_->GetLargestFreeSizeNoWaiting());
    147   int32 token = helper_->InsertToken();
    148   allocator_->FreePendingToken(offset, token);
    149 }
    150 
    151 // Checks the free-pending-token mechanism.
    152 TEST_F(RingBufferTest, TestFreePendingToken) {
    153   const unsigned int kSize = 16;
    154   const unsigned int kAllocCount = kBufferSize / kSize;
    155   CHECK(kAllocCount * kSize == kBufferSize);
    156 
    157   delay_set_token_ = true;
    158   // Allocate several buffers to fill in the memory.
    159   int32 tokens[kAllocCount];
    160   for (unsigned int ii = 0; ii < kAllocCount; ++ii) {
    161     RingBuffer::Offset offset = allocator_->Alloc(kSize);
    162     EXPECT_GE(kBufferSize, offset - kBaseOffset + kSize);
    163     tokens[ii] = helper_->InsertToken();
    164     allocator_->FreePendingToken(offset, tokens[ii]);
    165   }
    166 
    167   EXPECT_EQ(kBufferSize - (kSize * kAllocCount),
    168             allocator_->GetLargestFreeSizeNoWaiting());
    169 
    170   RunPendingSetToken();
    171 
    172   // This allocation will need to reclaim the space freed above, so that should
    173   // process the commands until a token is passed.
    174   RingBuffer::Offset offset1 = allocator_->Alloc(kSize);
    175   EXPECT_EQ(kBaseOffset, offset1);
    176 
    177   // Check that the token has indeed passed.
    178   EXPECT_LE(tokens[0], GetToken());
    179 
    180   allocator_->FreePendingToken(offset1, helper_->InsertToken());
    181 }
    182 
    183 // Tests GetLargestFreeSizeNoWaiting
    184 TEST_F(RingBufferTest, TestGetLargestFreeSizeNoWaiting) {
    185   EXPECT_EQ(kBufferSize, allocator_->GetLargestFreeSizeNoWaiting());
    186 
    187   RingBuffer::Offset offset = allocator_->Alloc(kBufferSize);
    188   EXPECT_EQ(0u, allocator_->GetLargestFreeSizeNoWaiting());
    189   allocator_->FreePendingToken(offset, helper_->InsertToken());
    190 }
    191 
    192 TEST_F(RingBufferTest, TestFreeBug) {
    193   // The first and second allocations must not match.
    194   const unsigned int kAlloc1 = 10;
    195   const unsigned int kAlloc2 = 20;
    196   RingBuffer::Offset offset = allocator_->Alloc(kAlloc1);
    197   EXPECT_EQ(kBufferSize - kAlloc1, allocator_->GetLargestFreeSizeNoWaiting());
    198   allocator_->FreePendingToken(offset, helper_.get()->InsertToken());
    199   offset = allocator_->Alloc(kAlloc2);
    200   EXPECT_EQ(kBufferSize - kAlloc1 - kAlloc2,
    201             allocator_->GetLargestFreeSizeNoWaiting());
    202   allocator_->FreePendingToken(offset, helper_.get()->InsertToken());
    203   offset = allocator_->Alloc(kBufferSize);
    204   EXPECT_EQ(0u, allocator_->GetLargestFreeSizeNoWaiting());
    205   allocator_->FreePendingToken(offset, helper_.get()->InsertToken());
    206 }
    207 
    208 // Test fixture for RingBufferWrapper test - Creates a
    209 // RingBufferWrapper, using a CommandBufferHelper with a mock
    210 // AsyncAPIInterface for its interface (calling it directly, not through the
    211 // RPC mechanism), making sure Noops are ignored and SetToken are properly
    212 // forwarded to the engine.
    213 class RingBufferWrapperTest : public BaseRingBufferTest {
    214  protected:
    215   virtual void SetUp() {
    216     BaseRingBufferTest::SetUp();
    217 
    218     // Though allocating this buffer isn't strictly necessary, it makes
    219     // allocations point to valid addresses, so they could be used for
    220     // something.
    221     buffer_.reset(new int8[kBufferSize + kBaseOffset]);
    222     buffer_start_ = buffer_.get() + kBaseOffset;
    223     allocator_.reset(new RingBufferWrapper(
    224         kBaseOffset, kBufferSize, helper_.get(), buffer_start_));
    225   }
    226 
    227   virtual void TearDown() {
    228     // If the GpuScheduler posts any tasks, this forces them to run.
    229     base::MessageLoop::current()->RunUntilIdle();
    230 
    231     BaseRingBufferTest::TearDown();
    232   }
    233 
    234   scoped_ptr<RingBufferWrapper> allocator_;
    235   scoped_ptr<int8[]> buffer_;
    236   int8* buffer_start_;
    237 };
    238 
    239 // Checks basic alloc and free.
    240 TEST_F(RingBufferWrapperTest, TestBasic) {
    241   const unsigned int kSize = 16;
    242   void* pointer = allocator_->Alloc(kSize);
    243   ASSERT_TRUE(pointer);
    244   EXPECT_LE(buffer_start_, static_cast<int8*>(pointer));
    245   EXPECT_GE(kBufferSize, static_cast<int8*>(pointer) - buffer_start_ + kSize);
    246 
    247   allocator_->FreePendingToken(pointer, helper_->InsertToken());
    248 
    249   int8* pointer_int8 = allocator_->AllocTyped<int8>(kSize);
    250   ASSERT_TRUE(pointer_int8);
    251   EXPECT_LE(buffer_start_, pointer_int8);
    252   EXPECT_GE(buffer_start_ + kBufferSize, pointer_int8 + kSize);
    253   allocator_->FreePendingToken(pointer_int8, helper_->InsertToken());
    254 
    255   unsigned int* pointer_uint = allocator_->AllocTyped<unsigned int>(kSize);
    256   ASSERT_TRUE(pointer_uint);
    257   EXPECT_LE(buffer_start_, reinterpret_cast<int8*>(pointer_uint));
    258   EXPECT_GE(buffer_start_ + kBufferSize,
    259             reinterpret_cast<int8* >(pointer_uint + kSize));
    260 
    261   // Check that it did allocate kSize * sizeof(unsigned int). We can't tell
    262   // directly, except from the remaining size.
    263   EXPECT_EQ(kBufferSize - kSize - kSize - kSize * sizeof(*pointer_uint),
    264             allocator_->GetLargestFreeSizeNoWaiting());
    265   allocator_->FreePendingToken(pointer_uint, helper_->InsertToken());
    266 }
    267 
    268 // Checks the free-pending-token mechanism.
    269 TEST_F(RingBufferWrapperTest, TestFreePendingToken) {
    270   const unsigned int kSize = 16;
    271   const unsigned int kAllocCount = kBufferSize / kSize;
    272   CHECK(kAllocCount * kSize == kBufferSize);
    273 
    274   delay_set_token_ = true;
    275   // Allocate several buffers to fill in the memory.
    276   int32 tokens[kAllocCount];
    277   for (unsigned int ii = 0; ii < kAllocCount; ++ii) {
    278     void* pointer = allocator_->Alloc(kSize);
    279     EXPECT_TRUE(pointer != NULL);
    280     tokens[ii] = helper_->InsertToken();
    281     allocator_->FreePendingToken(pointer, helper_->InsertToken());
    282   }
    283 
    284   EXPECT_EQ(kBufferSize - (kSize * kAllocCount),
    285             allocator_->GetLargestFreeSizeNoWaiting());
    286 
    287   RunPendingSetToken();
    288 
    289   // This allocation will need to reclaim the space freed above, so that should
    290   // process the commands until the token is passed.
    291   void* pointer1 = allocator_->Alloc(kSize);
    292   EXPECT_EQ(buffer_start_, static_cast<int8*>(pointer1));
    293 
    294   // Check that the token has indeed passed.
    295   EXPECT_LE(tokens[0], GetToken());
    296 
    297   allocator_->FreePendingToken(pointer1, helper_->InsertToken());
    298   EXPECT_LE(command_buffer_->GetState().token, helper_->InsertToken());
    299 }
    300 
    301 }  // namespace gpu
    302