ThreadCachedArenaTest.cpp File Reference

#include <folly/memory/ThreadCachedArena.h>
#include <algorithm>
#include <iterator>
#include <map>
#include <mutex>
#include <random>
#include <thread>
#include <unordered_map>
#include <glog/logging.h>
#include <folly/Benchmark.h>
#include <folly/Memory.h>
#include <folly/Range.h>
#include <folly/lang/Align.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Functions
	TEST (ThreadCachedArena, BlockSize)
	TEST (ThreadCachedArena, SingleThreaded)
	TEST (ThreadCachedArena, MultiThreaded)
	TEST (ThreadCachedArena, ThreadCachedArenaAllocator)
int	main (int argc, char *argv[])

Function Documentation

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 266 of file ThreadCachedArenaTest.cpp.

References testing::InitGoogleTest(), RUN_ALL_TESTS(), and folly::runBenchmarks().

                                 {
  testing::InitGoogleTest(&argc, argv);
  gflags::ParseCommandLineFlags(&argc, &argv, true);
  auto ret = RUN_ALL_TESTS();
  if (!ret && FLAGS_benchmark) {
    folly::runBenchmarks();
  }
  return ret;
}

TEST	(	ThreadCachedArena	,
		BlockSize
	)

Definition at line 95 of file ThreadCachedArenaTest.cpp.

References folly::ThreadCachedArena::allocate(), EXPECT_LE, folly::max_align_v, and uint8_t.

                                   {
  static const size_t alignment = max_align_v;
  static const size_t requestedBlockSize = 64;

  ThreadCachedArena arena(requestedBlockSize);
  size_t blockSize = alignment;
  uint8_t* prev = static_cast<uint8_t*>(arena.allocate(1));

  // Keep allocating until we're no longer one single alignment away from the
  // previous allocation -- that's when we've gotten to the next block.
  uint8_t* p;
  while ((p = static_cast<uint8_t*>(arena.allocate(1))) == prev + alignment) {
    prev = p;
    blockSize += alignment;
  }

  VLOG(1) << "Requested block size: " << requestedBlockSize
          << ", actual: " << blockSize;
  EXPECT_LE(requestedBlockSize, blockSize);
}

TEST	(	ThreadCachedArena	,
		SingleThreaded
	)

Definition at line 116 of file ThreadCachedArenaTest.cpp.

References EXPECT_EQ, EXPECT_GT, and folly::ThreadCachedArena::totalSize().

                                        {
  static const size_t requestedBlockSize = 64;
  ThreadCachedArena arena(requestedBlockSize);
  EXPECT_EQ(arena.totalSize(), sizeof(ThreadCachedArena));

  ArenaTester tester(arena);
  tester.allocate(100, 100 << 10);
  tester.verify();

  EXPECT_GT(arena.totalSize(), sizeof(ThreadCachedArena));
}

TEST	(	ThreadCachedArena	,
		MultiThreaded
	)

Definition at line 128 of file ThreadCachedArenaTest.cpp.

References i, folly::gen::move, folly::pushmi::detail::t, and threads.

                                       {
  static const size_t requestedBlockSize = 64;
  ThreadCachedArena arena(requestedBlockSize);
  ArenaTester mainTester(arena);

  // Do this twice, to catch the possibility that memory from the first
  // round gets freed
  static const size_t numThreads = 20;
  for (size_t i = 0; i < 2; i++) {
    std::vector<std::thread> threads;
    threads.reserve(numThreads);
    for (size_t j = 0; j < numThreads; j++) {
      threads.emplace_back([&arena, &mainTester]() {
        ArenaTester tester(arena);
        tester.allocate(500, 1 << 10);
        tester.verify();
        mainTester.merge(std::move(tester));
      });
    }
    for (auto& t : threads) {
      t.join();
    }
  }

  mainTester.verify();
}

TEST	(	ThreadCachedArena	,
		ThreadCachedArenaAllocator
	)

Definition at line 155 of file ThreadCachedArenaTest.cpp.

References folly::BENCHMARK(), folly::BENCHMARK_DRAW_LINE(), EXPECT_EQ, i, and map().

                                                    {
  using Map = std::unordered_map<
      int,
      int,
      std::hash<int>,
      std::equal_to<int>,
      ThreadCachedArenaAllocator<std::pair<const int, int>>>;

  static const size_t requestedBlockSize = 64;
  ThreadCachedArena arena(requestedBlockSize);

  Map map{0,
          std::hash<int>(),
          std::equal_to<int>(),
          ThreadCachedArenaAllocator<std::pair<const int, int>>(arena)};

  for (int i = 0; i < 1000; i++) {
    map[i] = i;
  }

  for (int i = 0; i < 1000; i++) {
    EXPECT_EQ(i, map[i]);
  }
}