Enforce a memory limit on MappedMemoryManager

gpu/command_buffer/client/mapped_memory_unittest.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.
 
 #include "gpu/command_buffer/client/mapped_memory.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "gpu/command_buffer/client/cmd_buffer_helper.h"
@@ skipping 288 matching lines @@
   ASSERT_TRUE(mem2);
   ASSERT_TRUE(mem3);
   EXPECT_NE(-1, id1);
   EXPECT_EQ(id1, id2);
   EXPECT_NE(id2, id3);
   EXPECT_EQ(0u, offset1);
   EXPECT_EQ(kSize, offset2);
   EXPECT_EQ(0u, offset3);
 }
 
+TEST_F(MappedMemoryManagerTest, MemoryLimit) {
+  const unsigned int kSize = 1024;
+  // Reset the manager with a memory limit.
+  manager_.reset(new MappedMemoryManager(helper_.get(), 2 * kSize));
+  manager_->set_chunk_size_multiple(2 * kSize);
+
+  // Allocate half a chunk worth of memory.
+  int32 id1 = -1;
+  unsigned int offset1 = 0xFFFFFFFFU;
+  void* mem1 = manager_->Alloc(kSize, &id1, &offset1);
+  ASSERT_TRUE(mem1);
+  EXPECT_NE(-1, id1);
+  EXPECT_EQ(0u, offset1);
+
+  // Allocate half a chunk worth of memory again.
+  // The same chunk will be used.
+  int32 id2 = -1;
+  unsigned int offset2 = 0xFFFFFFFFU;
+  void* mem2 = manager_->Alloc(kSize, &id2, &offset2);
+  ASSERT_TRUE(mem2);
+  EXPECT_NE(-1, id2);
+  EXPECT_EQ(kSize, offset2);
+
+  // Allocate half a chunk worth of memory. Since we reached
+  // the memory limit we'll wait tokens on existing chunks.

[piman, 2013/08/15 02:49:03]

Wait for what token? You didn't free anything pending token.

[kaanb, 2013/08/16 22:50:44]

Done.

+  int32 id3 = -1;
+  unsigned int offset3 = 0xFFFFFFFFU;
+  void* mem3 = manager_->Alloc(kSize, &id3, &offset3);
+  ASSERT_TRUE(mem3);

[no sievers, 2013/08/15 01:43:42]

I think this test shows that your patch does not necessarily work as expected.
I assume it's allocating again here instead of reusing.

What you are missing is the case where the mapped memory is IN_USE.

I'd keep this test to specify what the behavior should be for the corresponding
calling sequence (multiple Map calls without Unmap).

Maybe add another that mimicks the Map/Unmap, Map/Unmap, .. pattern. You would
explicitly have to insert the token and eventually signal it, see
FreePendingToken test above.

[no sievers, 2013/08/15 01:49:06]

Btw, which usage case are you trying to optimize again?
async uploads or not?

[kaanb, 2013/08/16 22:50:44]

Done.

[kaanb, 2013/08/16 22:50:44]

I think this optimization is oblivious to whether we use async uploads or not,
right?

+  EXPECT_NE(-1, id3);
+  EXPECT_EQ(0u, offset3);
+}
+
 }  // namespace gpu