gpu: Reuse transfer buffers more aggresively

gpu/command_buffer/client/fenced_allocator_test.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.
 
 // This file contains the tests for the FencedAllocator class.
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/aligned_memory.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 11 matching lines @@
 #endif
 
 namespace gpu {
 
 using testing::Return;
 using testing::Mock;
 using testing::Truly;
 using testing::Sequence;
 using testing::DoAll;
 using testing::Invoke;
+using testing::InvokeWithoutArgs;
 using testing::_;
 
 class BaseFencedAllocatorTest : public testing::Test {
  protected:
   static const unsigned int kBufferSize = 1024;
   static const int kAllocAlignment = 16;
 
   virtual void SetUp() {
     api_mock_.reset(new AsyncAPIMock);
     // ignore noops in the mock - we don't want to inspect the internals of the
@@ skipping 39 matching lines @@
   scoped_ptr<TransferBufferManagerInterface> transfer_buffer_manager_;
   scoped_ptr<CommandBufferService> command_buffer_;
   scoped_ptr<GpuScheduler> gpu_scheduler_;
   scoped_ptr<CommandBufferHelper> helper_;
 };
 
 #ifndef _MSC_VER
 const unsigned int BaseFencedAllocatorTest::kBufferSize;
 #endif
 
+namespace {
+void EmptyPoll() {
+}
+}
+
 // Test fixture for FencedAllocator test - Creates a FencedAllocator, using a
 // CommandBufferHelper with a mock AsyncAPIInterface for its interface (calling
 // it directly, not through the RPC mechanism), making sure Noops are ignored
 // and SetToken are properly forwarded to the engine.
 class FencedAllocatorTest : public BaseFencedAllocatorTest {
  protected:
   virtual void SetUp() {
     BaseFencedAllocatorTest::SetUp();
-    allocator_.reset(new FencedAllocator(kBufferSize, helper_.get()));
+    allocator_.reset(new FencedAllocator(kBufferSize,
+                                         helper_.get(),
+                                         base::Bind(&EmptyPoll)));
   }
 
   virtual void TearDown() {
     // If the GpuScheduler posts any tasks, this forces them to run.
     base::MessageLoop::current()->RunUntilIdle();
 
     EXPECT_TRUE(allocator_->CheckConsistency());
 
     BaseFencedAllocatorTest::TearDown();
   }
@@ skipping 274 matching lines @@
   // Check that the token has indeed passed.
   EXPECT_LE(token, GetToken());
   allocator_->Free(offset);
 
   // Everything now has been freed...
   EXPECT_EQ(kBufferSize, allocator_->GetLargestFreeOrPendingSize());
   // ... for real.
   EXPECT_EQ(kBufferSize, allocator_->GetLargestFreeSize());
 }
 
+class FencedAllocatorPollTest : public BaseFencedAllocatorTest {
+ public:
+  static const unsigned int kAllocSize = 128;
+
+  MOCK_METHOD0(MockedPoll, void());
+
+ protected:
+  virtual void TearDown() {
+    // If the GpuScheduler posts any tasks, this forces them to run.
+    base::MessageLoop::current()->RunUntilIdle();
+
+    BaseFencedAllocatorTest::TearDown();
+  }
+};
+
+TEST_F(FencedAllocatorPollTest, TestPoll) {
+  scoped_ptr<FencedAllocator> allocator(
+      new FencedAllocator(kBufferSize,
+                          helper_.get(),
+                          base::Bind(&FencedAllocatorPollTest::MockedPoll,
+                                     base::Unretained(this))));
+
+  FencedAllocator::Offset mem1 = allocator->Alloc(kAllocSize);
+  FencedAllocator::Offset mem2 = allocator->Alloc(kAllocSize);
+  EXPECT_NE(mem1, FencedAllocator::kInvalidOffset);
+  EXPECT_NE(mem2, FencedAllocator::kInvalidOffset);
+  EXPECT_TRUE(allocator->CheckConsistency());
+  EXPECT_EQ(allocator->bytes_in_use(), kAllocSize * 2);
+
+  // Check that no-op Poll doesn't affect the state.
+  EXPECT_CALL(*this, MockedPoll()).RetiresOnSaturation();
+  allocator->FreeUnused();
+  EXPECT_TRUE(allocator->CheckConsistency());
+  EXPECT_EQ(allocator->bytes_in_use(), kAllocSize * 2);
+
+  // Check that freeing in Poll works.
+  base::Closure free_mem1_closure =
+      base::Bind(&FencedAllocator::Free,
+                 base::Unretained(allocator.get()),
+                 mem1);
+  EXPECT_CALL(*this, MockedPoll())
+      .WillOnce(InvokeWithoutArgs(&free_mem1_closure, &base::Closure::Run))
+      .RetiresOnSaturation();
+  allocator->FreeUnused();
+  EXPECT_TRUE(allocator->CheckConsistency());
+  EXPECT_EQ(allocator->bytes_in_use(), kAllocSize * 1);
+
+  // Check that freeing still works.
+  EXPECT_CALL(*this, MockedPoll()).RetiresOnSaturation();
+  allocator->Free(mem2);
+  allocator->FreeUnused();
+  EXPECT_TRUE(allocator->CheckConsistency());
+  EXPECT_EQ(allocator->bytes_in_use(), 0u);
+
+  allocator.reset();
+}
+
 // Test fixture for FencedAllocatorWrapper test - Creates a
 // FencedAllocatorWrapper, using a CommandBufferHelper with a mock
 // AsyncAPIInterface for its interface (calling it directly, not through the
 // RPC mechanism), making sure Noops are ignored and SetToken are properly
 // forwarded to the engine.
 class FencedAllocatorWrapperTest : public BaseFencedAllocatorTest {
  protected:
   virtual void SetUp() {
     BaseFencedAllocatorTest::SetUp();
 
     // Though allocating this buffer isn't strictly necessary, it makes
     // allocations point to valid addresses, so they could be used for
     // something.
     buffer_.reset(static_cast<char*>(base::AlignedAlloc(
         kBufferSize, kAllocAlignment)));
-    allocator_.reset(new FencedAllocatorWrapper(kBufferSize, helper_.get(),
+    allocator_.reset(new FencedAllocatorWrapper(kBufferSize,
+                                                helper_.get(),
+                                                base::Bind(&EmptyPoll),
                                                 buffer_.get()));
   }
 
   virtual void TearDown() {
     // If the GpuScheduler posts any tasks, this forces them to run.
     base::MessageLoop::current()->RunUntilIdle();
 
     EXPECT_TRUE(allocator_->CheckConsistency());
 
     BaseFencedAllocatorTest::TearDown();
@@ skipping 149 matching lines @@
   EXPECT_LE(token, GetToken());
 
   // Free up everything.
   for (unsigned int i = 0; i < kAllocCount; ++i) {
     allocator_->Free(pointers[i]);
     EXPECT_TRUE(allocator_->CheckConsistency());
   }
 }
 
 }  // namespace gpu