gpu/command_buffer/client/fenced_allocator_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 // This file contains the tests for the FencedAllocator class.
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/memory/aligned_memory.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "gpu/command_buffer/client/cmd_buffer_helper.h"
  12 #include "gpu/command_buffer/client/fenced_allocator.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 BaseFencedAllocatorTest : public testing::Test {
  35  protected:
  36   static const unsigned int kBufferSize = 1024;
  37   static const int kAllocAlignment = 16;
  38
  39   virtual void SetUp() {
  40     api_mock_.reset(new AsyncAPIMock);
  41     // ignore noops in the mock - we don't want to inspect the internals of the
  42     // helper.
  43     EXPECT_CALL(*api_mock_, DoCommand(cmd::kNoop, 0, _))
  44         .WillRepeatedly(Return(error::kNoError));
  45     // Forward the SetToken calls to the engine
  46     EXPECT_CALL(*api_mock_.get(), DoCommand(cmd::kSetToken, 1, _))
  47         .WillRepeatedly(DoAll(Invoke(api_mock_.get(), &AsyncAPIMock::SetToken),
  48                               Return(error::kNoError)));
  49
  50     {
  51       TransferBufferManager* manager = new TransferBufferManager();
  52       transfer_buffer_manager_.reset(manager);
  53       EXPECT_TRUE(manager->Initialize());
  54     }
  55     command_buffer_.reset(
  56         new CommandBufferService(transfer_buffer_manager_.get()));
  57     EXPECT_TRUE(command_buffer_->Initialize());
  58
  59     gpu_scheduler_.reset(new GpuScheduler(
  60         command_buffer_.get(), api_mock_.get(), NULL));
  61     command_buffer_->SetPutOffsetChangeCallback(base::Bind(
  62         &GpuScheduler::PutChanged, base::Unretained(gpu_scheduler_.get())));
  63     command_buffer_->SetGetBufferChangeCallback(base::Bind(
  64         &GpuScheduler::SetGetBuffer, base::Unretained(gpu_scheduler_.get())));
  65
  66     api_mock_->set_engine(gpu_scheduler_.get());
  67
  68     helper_.reset(new CommandBufferHelper(command_buffer_.get()));
  69     helper_->Initialize(kBufferSize);
  70   }
  71
  72   int32 GetToken() {
  73     return command_buffer_->GetState().token;
  74   }
  75
  76 #if defined(OS_MACOSX)
  77   base::mac::ScopedNSAutoreleasePool autorelease_pool_;
  78 #endif
  79   base::MessageLoop message_loop_;
  80   scoped_ptr<AsyncAPIMock> api_mock_;
  81   scoped_ptr<TransferBufferManagerInterface> transfer_buffer_manager_;
  82   scoped_ptr<CommandBufferService> command_buffer_;
  83   scoped_ptr<GpuScheduler> gpu_scheduler_;
  84   scoped_ptr<CommandBufferHelper> helper_;
  85 };
  86
  87 #ifndef _MSC_VER
  88 const unsigned int BaseFencedAllocatorTest::kBufferSize;
  89 #endif
  90
  91 // Test fixture for FencedAllocator test - Creates a FencedAllocator, using a
  92 // CommandBufferHelper with a mock AsyncAPIInterface for its interface (calling
  93 // it directly, not through the RPC mechanism), making sure Noops are ignored
  94 // and SetToken are properly forwarded to the engine.
  95 class FencedAllocatorTest : public BaseFencedAllocatorTest {
  96  protected:
  97   virtual void SetUp() {
  98     BaseFencedAllocatorTest::SetUp();
  99     allocator_.reset(new FencedAllocator(kBufferSize, helper_.get()));
 100   }
 101
 102   virtual void TearDown() {
 103     // If the GpuScheduler posts any tasks, this forces them to run.
 104     base::MessageLoop::current()->RunUntilIdle();
 105
 106     EXPECT_TRUE(allocator_->CheckConsistency());
 107
 108     BaseFencedAllocatorTest::TearDown();
 109   }
 110
 111   scoped_ptr<FencedAllocator> allocator_;
 112 };
 113
 114 // Checks basic alloc and free.
 115 TEST_F(FencedAllocatorTest, TestBasic) {
 116   allocator_->CheckConsistency();
 117   EXPECT_FALSE(allocator_->InUse());
 118
 119   const unsigned int kSize = 16;
 120   FencedAllocator::Offset offset = allocator_->Alloc(kSize);
 121   EXPECT_TRUE(allocator_->InUse());
 122   EXPECT_NE(FencedAllocator::kInvalidOffset, offset);
 123   EXPECT_GE(kBufferSize, offset+kSize);
 124   EXPECT_TRUE(allocator_->CheckConsistency());
 125
 126   allocator_->Free(offset);
 127   EXPECT_FALSE(allocator_->InUse());
 128   EXPECT_TRUE(allocator_->CheckConsistency());
 129 }
 130
 131 // Test alloc 0 fails.
 132 TEST_F(FencedAllocatorTest, TestAllocZero) {
 133   FencedAllocator::Offset offset = allocator_->Alloc(0);
 134   EXPECT_EQ(FencedAllocator::kInvalidOffset, offset);
 135   EXPECT_FALSE(allocator_->InUse());
 136   EXPECT_TRUE(allocator_->CheckConsistency());
 137 }
 138
 139 // Checks out-of-memory condition.
 140 TEST_F(FencedAllocatorTest, TestOutOfMemory) {
 141   EXPECT_TRUE(allocator_->CheckConsistency());
 142
 143   const unsigned int kSize = 16;
 144   const unsigned int kAllocCount = kBufferSize / kSize;
 145   CHECK(kAllocCount * kSize == kBufferSize);
 146
 147   // Allocate several buffers to fill in the memory.
 148   FencedAllocator::Offset offsets[kAllocCount];
 149   for (unsigned int i = 0; i < kAllocCount; ++i) {
 150     offsets[i] = allocator_->Alloc(kSize);
 151     EXPECT_NE(FencedAllocator::kInvalidOffset, offsets[i]);
 152     EXPECT_GE(kBufferSize, offsets[i]+kSize);
 153     EXPECT_TRUE(allocator_->CheckConsistency());
 154   }
 155
 156   // This allocation should fail.
 157   FencedAllocator::Offset offset_failed = allocator_->Alloc(kSize);
 158   EXPECT_EQ(FencedAllocator::kInvalidOffset, offset_failed);
 159   EXPECT_TRUE(allocator_->CheckConsistency());
 160
 161   // Free one successful allocation, reallocate with half the size
 162   allocator_->Free(offsets[0]);
 163   EXPECT_TRUE(allocator_->CheckConsistency());
 164   offsets[0] = allocator_->Alloc(kSize/2);
 165   EXPECT_NE(FencedAllocator::kInvalidOffset, offsets[0]);
 166   EXPECT_GE(kBufferSize, offsets[0]+kSize);
 167   EXPECT_TRUE(allocator_->CheckConsistency());
 168
 169   // This allocation should fail as well.
 170   offset_failed = allocator_->Alloc(kSize);
 171   EXPECT_EQ(FencedAllocator::kInvalidOffset, offset_failed);
 172   EXPECT_TRUE(allocator_->CheckConsistency());
 173
 174   // Free up everything.
 175   for (unsigned int i = 0; i < kAllocCount; ++i) {
 176     allocator_->Free(offsets[i]);
 177     EXPECT_TRUE(allocator_->CheckConsistency());
 178   }
 179 }
 180
 181 // Checks the free-pending-token mechanism.
 182 TEST_F(FencedAllocatorTest, TestFreePendingToken) {
 183   EXPECT_TRUE(allocator_->CheckConsistency());
 184
 185   const unsigned int kSize = 16;
 186   const unsigned int kAllocCount = kBufferSize / kSize;
 187   CHECK(kAllocCount * kSize == kBufferSize);
 188
 189   // Allocate several buffers to fill in the memory.
 190   FencedAllocator::Offset offsets[kAllocCount];
 191   for (unsigned int i = 0; i < kAllocCount; ++i) {
 192     offsets[i] = allocator_->Alloc(kSize);
 193     EXPECT_NE(FencedAllocator::kInvalidOffset, offsets[i]);
 194     EXPECT_GE(kBufferSize, offsets[i]+kSize);
 195     EXPECT_TRUE(allocator_->CheckConsistency());
 196   }
 197
 198   // This allocation should fail.
 199   FencedAllocator::Offset offset_failed = allocator_->Alloc(kSize);
 200   EXPECT_EQ(FencedAllocator::kInvalidOffset, offset_failed);
 201   EXPECT_TRUE(allocator_->CheckConsistency());
 202
 203   // Free one successful allocation, pending fence.
 204   int32 token = helper_.get()->InsertToken();
 205   allocator_->FreePendingToken(offsets[0], token);
 206   EXPECT_TRUE(allocator_->CheckConsistency());
 207
 208   // The way we hooked up the helper and engine, it won't process commands
 209   // until it has to wait for something. Which means the token shouldn't have
 210   // passed yet at this point.
 211   EXPECT_GT(token, GetToken());
 212
 213   // This allocation will need to reclaim the space freed above, so that should
 214   // process the commands until the token is passed.
 215   offsets[0] = allocator_->Alloc(kSize);
 216   EXPECT_NE(FencedAllocator::kInvalidOffset, offsets[0]);
 217   EXPECT_GE(kBufferSize, offsets[0]+kSize);
 218   EXPECT_TRUE(allocator_->CheckConsistency());
 219   // Check that the token has indeed passed.
 220   EXPECT_LE(token, GetToken());
 221
 222   // Free up everything.
 223   for (unsigned int i = 0; i < kAllocCount; ++i) {
 224     allocator_->Free(offsets[i]);
 225     EXPECT_TRUE(allocator_->CheckConsistency());
 226   }
 227 }
 228
 229 // Checks the free-pending-token mechanism using FreeUnused
 230 TEST_F(FencedAllocatorTest, FreeUnused) {
 231   EXPECT_TRUE(allocator_->CheckConsistency());
 232
 233   const unsigned int kSize = 16;
 234   const unsigned int kAllocCount = kBufferSize / kSize;
 235   CHECK(kAllocCount * kSize == kBufferSize);
 236
 237   // Allocate several buffers to fill in the memory.
 238   FencedAllocator::Offset offsets[kAllocCount];
 239   for (unsigned int i = 0; i < kAllocCount; ++i) {
 240     offsets[i] = allocator_->Alloc(kSize);
 241     EXPECT_NE(FencedAllocator::kInvalidOffset, offsets[i]);
 242     EXPECT_GE(kBufferSize, offsets[i]+kSize);
 243     EXPECT_TRUE(allocator_->CheckConsistency());
 244   }
 245   EXPECT_TRUE(allocator_->InUse());
 246
 247   // No memory should be available.
 248   EXPECT_EQ(0u, allocator_->GetLargestFreeSize());
 249
 250   // Free one successful allocation, pending fence.
 251   int32 token = helper_.get()->InsertToken();
 252   allocator_->FreePendingToken(offsets[0], token);
 253   EXPECT_TRUE(allocator_->CheckConsistency());
 254
 255   // Force the command buffer to process the token.
 256   helper_->Finish();
 257
 258   // Tell the allocator to update what's available based on the current token.
 259   allocator_->FreeUnused();
 260
 261   // Check that the new largest free size takes into account the unused block.
 262   EXPECT_EQ(kSize, allocator_->GetLargestFreeSize());
 263
 264   // Free two more.
 265   token = helper_.get()->InsertToken();
 266   allocator_->FreePendingToken(offsets[1], token);
 267   token = helper_.get()->InsertToken();
 268   allocator_->FreePendingToken(offsets[2], token);
 269   EXPECT_TRUE(allocator_->CheckConsistency());
 270
 271   // Check that nothing has changed.
 272   EXPECT_EQ(kSize, allocator_->GetLargestFreeSize());
 273
 274   // Force the command buffer to process the token.
 275   helper_->Finish();
 276
 277   // Tell the allocator to update what's available based on the current token.
 278   allocator_->FreeUnused();
 279
 280   // Check that the new largest free size takes into account the unused blocks.
 281   EXPECT_EQ(kSize * 3, allocator_->GetLargestFreeSize());
 282   EXPECT_TRUE(allocator_->InUse());
 283
 284   // Free up everything.
 285   for (unsigned int i = 3; i < kAllocCount; ++i) {
 286     allocator_->Free(offsets[i]);
 287     EXPECT_TRUE(allocator_->CheckConsistency());
 288   }
 289   EXPECT_FALSE(allocator_->InUse());
 290 }
 291
 292 // Tests GetLargestFreeSize
 293 TEST_F(FencedAllocatorTest, TestGetLargestFreeSize) {
 294   EXPECT_TRUE(allocator_->CheckConsistency());
 295   EXPECT_EQ(kBufferSize, allocator_->GetLargestFreeSize());
 296
 297   FencedAllocator::Offset offset = allocator_->Alloc(kBufferSize);
 298   ASSERT_NE(FencedAllocator::kInvalidOffset, offset);
 299   EXPECT_EQ(0u, allocator_->GetLargestFreeSize());
 300   allocator_->Free(offset);
 301   EXPECT_EQ(kBufferSize, allocator_->GetLargestFreeSize());
 302
 303   const unsigned int kSize = 16;
 304   offset = allocator_->Alloc(kSize);
 305   ASSERT_NE(FencedAllocator::kInvalidOffset, offset);
 306   // The following checks that the buffer is allocated "smartly" - which is
 307   // dependent on the implementation. But both first-fit or best-fit would
 308   // ensure that.
 309   EXPECT_EQ(kBufferSize - kSize, allocator_->GetLargestFreeSize());
 310
 311   // Allocate 2 more buffers (now 3), and then free the first two. This is to
 312   // ensure a hole. Note that this is dependent on the first-fit current
 313   // implementation.
 314   FencedAllocator::Offset offset1 = allocator_->Alloc(kSize);
 315   ASSERT_NE(FencedAllocator::kInvalidOffset, offset1);
 316   FencedAllocator::Offset offset2 = allocator_->Alloc(kSize);
 317   ASSERT_NE(FencedAllocator::kInvalidOffset, offset2);
 318   allocator_->Free(offset);
 319   allocator_->Free(offset1);
 320   EXPECT_EQ(kBufferSize - 3 * kSize, allocator_->GetLargestFreeSize());
 321
 322   offset = allocator_->Alloc(kBufferSize - 3 * kSize);
 323   ASSERT_NE(FencedAllocator::kInvalidOffset, offset);
 324   EXPECT_EQ(2 * kSize, allocator_->GetLargestFreeSize());
 325
 326   offset1 = allocator_->Alloc(2 * kSize);
 327   ASSERT_NE(FencedAllocator::kInvalidOffset, offset1);
 328   EXPECT_EQ(0u, allocator_->GetLargestFreeSize());
 329
 330   allocator_->Free(offset);
 331   allocator_->Free(offset1);
 332   allocator_->Free(offset2);
 333 }
 334
 335 // Tests GetLargestFreeOrPendingSize
 336 TEST_F(FencedAllocatorTest, TestGetLargestFreeOrPendingSize) {
 337   EXPECT_TRUE(allocator_->CheckConsistency());
 338   EXPECT_EQ(kBufferSize, allocator_->GetLargestFreeOrPendingSize());
 339
 340   FencedAllocator::Offset offset = allocator_->Alloc(kBufferSize);
 341   ASSERT_NE(FencedAllocator::kInvalidOffset, offset);
 342   EXPECT_EQ(0u, allocator_->GetLargestFreeOrPendingSize());
 343   allocator_->Free(offset);
 344   EXPECT_EQ(kBufferSize, allocator_->GetLargestFreeOrPendingSize());
 345
 346   const unsigned int kSize = 16;
 347   offset = allocator_->Alloc(kSize);
 348   ASSERT_NE(FencedAllocator::kInvalidOffset, offset);
 349   // The following checks that the buffer is allocates "smartly" - which is
 350   // dependent on the implementation. But both first-fit or best-fit would
 351   // ensure that.
 352   EXPECT_EQ(kBufferSize - kSize, allocator_->GetLargestFreeOrPendingSize());
 353
 354   // Allocate 2 more buffers (now 3), and then free the first two. This is to
 355   // ensure a hole. Note that this is dependent on the first-fit current
 356   // implementation.
 357   FencedAllocator::Offset offset1 = allocator_->Alloc(kSize);
 358   ASSERT_NE(FencedAllocator::kInvalidOffset, offset1);
 359   FencedAllocator::Offset offset2 = allocator_->Alloc(kSize);
 360   ASSERT_NE(FencedAllocator::kInvalidOffset, offset2);
 361   allocator_->Free(offset);
 362   allocator_->Free(offset1);
 363   EXPECT_EQ(kBufferSize - 3 * kSize,
 364             allocator_->GetLargestFreeOrPendingSize());
 365
 366   // Free the last one, pending a token.
 367   int32 token = helper_.get()->InsertToken();
 368   allocator_->FreePendingToken(offset2, token);
 369
 370   // Now all the buffers have been freed...
 371   EXPECT_EQ(kBufferSize, allocator_->GetLargestFreeOrPendingSize());
 372   // .. but one is still waiting for the token.
 373   EXPECT_EQ(kBufferSize - 3 * kSize,
 374             allocator_->GetLargestFreeSize());
 375
 376   // The way we hooked up the helper and engine, it won't process commands
 377   // until it has to wait for something. Which means the token shouldn't have
 378   // passed yet at this point.
 379   EXPECT_GT(token, GetToken());
 380   // This allocation will need to reclaim the space freed above, so that should
 381   // process the commands until the token is passed, but it will succeed.
 382   offset = allocator_->Alloc(kBufferSize);
 383   ASSERT_NE(FencedAllocator::kInvalidOffset, offset);
 384   // Check that the token has indeed passed.
 385   EXPECT_LE(token, GetToken());
 386   allocator_->Free(offset);
 387
 388   // Everything now has been freed...
 389   EXPECT_EQ(kBufferSize, allocator_->GetLargestFreeOrPendingSize());
 390   // ... for real.
 391   EXPECT_EQ(kBufferSize, allocator_->GetLargestFreeSize());
 392 }
 393
 394 // Test fixture for FencedAllocatorWrapper test - Creates a
 395 // FencedAllocatorWrapper, using a CommandBufferHelper with a mock
 396 // AsyncAPIInterface for its interface (calling it directly, not through the
 397 // RPC mechanism), making sure Noops are ignored and SetToken are properly
 398 // forwarded to the engine.
 399 class FencedAllocatorWrapperTest : public BaseFencedAllocatorTest {
 400  protected:
 401   virtual void SetUp() {
 402     BaseFencedAllocatorTest::SetUp();
 403
 404     // Though allocating this buffer isn't strictly necessary, it makes
 405     // allocations point to valid addresses, so they could be used for
 406     // something.
 407     buffer_.reset(static_cast<char*>(base::AlignedAlloc(
 408         kBufferSize, kAllocAlignment)));
 409     allocator_.reset(new FencedAllocatorWrapper(kBufferSize, helper_.get(),
 410                                                 buffer_.get()));
 411   }
 412
 413   virtual void TearDown() {
 414     // If the GpuScheduler posts any tasks, this forces them to run.
 415     base::MessageLoop::current()->RunUntilIdle();
 416
 417     EXPECT_TRUE(allocator_->CheckConsistency());
 418
 419     BaseFencedAllocatorTest::TearDown();
 420   }
 421
 422   scoped_ptr<FencedAllocatorWrapper> allocator_;
 423   scoped_ptr_malloc<char, base::ScopedPtrAlignedFree> buffer_;
 424 };
 425
 426 // Checks basic alloc and free.
 427 TEST_F(FencedAllocatorWrapperTest, TestBasic) {
 428   allocator_->CheckConsistency();
 429
 430   const unsigned int kSize = 16;
 431   void *pointer = allocator_->Alloc(kSize);
 432   ASSERT_TRUE(pointer);
 433   EXPECT_LE(buffer_.get(), static_cast<char *>(pointer));
 434   EXPECT_GE(kBufferSize, static_cast<char *>(pointer) - buffer_.get() + kSize);
 435   EXPECT_TRUE(allocator_->CheckConsistency());
 436
 437   allocator_->Free(pointer);
 438   EXPECT_TRUE(allocator_->CheckConsistency());
 439
 440   char *pointer_char = allocator_->AllocTyped<char>(kSize);
 441   ASSERT_TRUE(pointer_char);
 442   EXPECT_LE(buffer_.get(), pointer_char);
 443   EXPECT_GE(buffer_.get() + kBufferSize, pointer_char + kSize);
 444   allocator_->Free(pointer_char);
 445   EXPECT_TRUE(allocator_->CheckConsistency());
 446
 447   unsigned int *pointer_uint = allocator_->AllocTyped<unsigned int>(kSize);
 448   ASSERT_TRUE(pointer_uint);
 449   EXPECT_LE(buffer_.get(), reinterpret_cast<char *>(pointer_uint));
 450   EXPECT_GE(buffer_.get() + kBufferSize,
 451             reinterpret_cast<char *>(pointer_uint + kSize));
 452
 453   // Check that it did allocate kSize * sizeof(unsigned int). We can't tell
 454   // directly, except from the remaining size.
 455   EXPECT_EQ(kBufferSize - kSize * sizeof(*pointer_uint),
 456             allocator_->GetLargestFreeSize());
 457   allocator_->Free(pointer_uint);
 458 }
 459
 460 // Test alloc 0 fails.
 461 TEST_F(FencedAllocatorWrapperTest, TestAllocZero) {
 462   allocator_->CheckConsistency();
 463
 464   void *pointer = allocator_->Alloc(0);
 465   ASSERT_FALSE(pointer);
 466   EXPECT_TRUE(allocator_->CheckConsistency());
 467 }
 468
 469 // Checks that allocation offsets are aligned to multiples of 16 bytes.
 470 TEST_F(FencedAllocatorWrapperTest, TestAlignment) {
 471   allocator_->CheckConsistency();
 472
 473   const unsigned int kSize1 = 75;
 474   void *pointer1 = allocator_->Alloc(kSize1);
 475   ASSERT_TRUE(pointer1);
 476   EXPECT_EQ(reinterpret_cast<intptr_t>(pointer1) & (kAllocAlignment - 1), 0);
 477   EXPECT_TRUE(allocator_->CheckConsistency());
 478
 479   const unsigned int kSize2 = 43;
 480   void *pointer2 = allocator_->Alloc(kSize2);
 481   ASSERT_TRUE(pointer2);
 482   EXPECT_EQ(reinterpret_cast<intptr_t>(pointer2) & (kAllocAlignment - 1), 0);
 483   EXPECT_TRUE(allocator_->CheckConsistency());
 484
 485   allocator_->Free(pointer2);
 486   EXPECT_TRUE(allocator_->CheckConsistency());
 487
 488   allocator_->Free(pointer1);
 489   EXPECT_TRUE(allocator_->CheckConsistency());
 490 }
 491
 492 // Checks out-of-memory condition.
 493 TEST_F(FencedAllocatorWrapperTest, TestOutOfMemory) {
 494   allocator_->CheckConsistency();
 495
 496   const unsigned int kSize = 16;
 497   const unsigned int kAllocCount = kBufferSize / kSize;
 498   CHECK(kAllocCount * kSize == kBufferSize);
 499
 500   // Allocate several buffers to fill in the memory.
 501   void *pointers[kAllocCount];
 502   for (unsigned int i = 0; i < kAllocCount; ++i) {
 503     pointers[i] = allocator_->Alloc(kSize);
 504     EXPECT_TRUE(pointers[i]);
 505     EXPECT_TRUE(allocator_->CheckConsistency());
 506   }
 507
 508   // This allocation should fail.
 509   void *pointer_failed = allocator_->Alloc(kSize);
 510   EXPECT_FALSE(pointer_failed);
 511   EXPECT_TRUE(allocator_->CheckConsistency());
 512
 513   // Free one successful allocation, reallocate with half the size
 514   allocator_->Free(pointers[0]);
 515   EXPECT_TRUE(allocator_->CheckConsistency());
 516   pointers[0] = allocator_->Alloc(kSize/2);
 517   EXPECT_TRUE(pointers[0]);
 518   EXPECT_TRUE(allocator_->CheckConsistency());
 519
 520   // This allocation should fail as well.
 521   pointer_failed = allocator_->Alloc(kSize);
 522   EXPECT_FALSE(pointer_failed);
 523   EXPECT_TRUE(allocator_->CheckConsistency());
 524
 525   // Free up everything.
 526   for (unsigned int i = 0; i < kAllocCount; ++i) {
 527     allocator_->Free(pointers[i]);
 528     EXPECT_TRUE(allocator_->CheckConsistency());
 529   }
 530 }
 531
 532 // Checks the free-pending-token mechanism.
 533 TEST_F(FencedAllocatorWrapperTest, TestFreePendingToken) {
 534   allocator_->CheckConsistency();
 535
 536   const unsigned int kSize = 16;
 537   const unsigned int kAllocCount = kBufferSize / kSize;
 538   CHECK(kAllocCount * kSize == kBufferSize);
 539
 540   // Allocate several buffers to fill in the memory.
 541   void *pointers[kAllocCount];
 542   for (unsigned int i = 0; i < kAllocCount; ++i) {
 543     pointers[i] = allocator_->Alloc(kSize);
 544     EXPECT_TRUE(pointers[i]);
 545     EXPECT_TRUE(allocator_->CheckConsistency());
 546   }
 547
 548   // This allocation should fail.
 549   void *pointer_failed = allocator_->Alloc(kSize);
 550   EXPECT_FALSE(pointer_failed);
 551   EXPECT_TRUE(allocator_->CheckConsistency());
 552
 553   // Free one successful allocation, pending fence.
 554   int32 token = helper_.get()->InsertToken();
 555   allocator_->FreePendingToken(pointers[0], token);
 556   EXPECT_TRUE(allocator_->CheckConsistency());
 557
 558   // The way we hooked up the helper and engine, it won't process commands
 559   // until it has to wait for something. Which means the token shouldn't have
 560   // passed yet at this point.
 561   EXPECT_GT(token, GetToken());
 562
 563   // This allocation will need to reclaim the space freed above, so that should
 564   // process the commands until the token is passed.
 565   pointers[0] = allocator_->Alloc(kSize);
 566   EXPECT_TRUE(pointers[0]);
 567   EXPECT_TRUE(allocator_->CheckConsistency());
 568   // Check that the token has indeed passed.
 569   EXPECT_LE(token, GetToken());
 570
 571   // Free up everything.
 572   for (unsigned int i = 0; i < kAllocCount; ++i) {
 573     allocator_->Free(pointers[i]);
 574     EXPECT_TRUE(allocator_->CheckConsistency());
 575   }
 576 }
 577
 578 }  // namespace gpu