Function TEST

be/src/runtime/free-pool-test.cc:29–115

namespace impala {

TEST(FreePoolTest, Basic) {
  MemTracker tracker;
  MemPool mem_pool(&tracker);
  FreePool pool(&mem_pool);

  // Start off with some corner cases.
  uint8_t* p1 = pool.Allocate(0);
  ASSERT_TRUE(p1 != NULL);
  pool.Free(p1);
  pool.Free(NULL);

  EXPECT_EQ(mem_pool.total_allocated_bytes(), 0);
  p1 = pool.Allocate(1);
  *p1 = 111; // Scribble something to make sure it doesn't mess up the list.
  ASSERT_TRUE(p1 != NULL);
  EXPECT_EQ(mem_pool.total_allocated_bytes(), 16);
  pool.Free(p1);

  // Allocating this should return p again.
  for (int i = 0; i < 10; ++i) {
    uint8_t* p2 = pool.Allocate(1);
    *p2 = 111;
    EXPECT_EQ(p1, p2);
    EXPECT_EQ(mem_pool.total_allocated_bytes(), 16);
    pool.Free(p2);
  }

  uint8_t* p2 = pool.Allocate(1);
  *p2 = 111;
  // p3 will cause a new allocation.
  uint8_t* p3 = pool.Allocate(1);
  *p3 = 111;
  EXPECT_TRUE(p1 == p2);
  EXPECT_TRUE(p1 != p3);
  EXPECT_EQ(mem_pool.total_allocated_bytes(), 32);
  pool.Free(p2);
  pool.Free(p3);

  // We know have 2 1 byte allocations, which were rounded up to 8 bytes. Make an 8
  // byte allocation, which can reuse one of the existing ones.
  uint8_t* p4 = pool.Allocate(2);
  memset(p4, 123, 2);
  EXPECT_EQ(mem_pool.total_allocated_bytes(), 32);
  EXPECT_TRUE(p4 == p1 || p4 == p2 || p4 == p3);
  pool.Free(p4);

  // Make a 9 byte allocation, which requires a new allocation.
  uint8_t* p5 = pool.Allocate(9);
  memset(p5, 123, 9);
  EXPECT_EQ(mem_pool.total_allocated_bytes(), 56);
  pool.Free(p5);
  EXPECT_TRUE(p5 != p1);
  EXPECT_TRUE(p5 != p2);
  EXPECT_TRUE(p5 != p3);

  // Everything's freed. Try grabbing the ones that have been allocated.
  p1 = pool.Allocate(1);
  *p1 = 123;