kernel/lib/fbl/arena_tests.cpp - zircon - Git at Google

 // Copyright 2016 The Fuchsia Authors
 //
 // Use of this source code is governed by a MIT-style
 // license that can be found in the LICENSE file or at
 // https://opensource.org/licenses/MIT

 #include <fbl/arena.h>

 #include <vm/vm_aspace.h>
 #include <fbl/alloc_checker.h>
 #include <unittest.h>

 using fbl::Arena;

 struct TestObj {
     int xx, yy, zz;
 };

 static bool init_null_name_succeeds(void* context) {
     BEGIN_TEST;
     Arena arena;
     EXPECT_EQ(ZX_OK, arena.Init(nullptr, sizeof(TestObj), 16), "");
     END_TEST;
 }

 static bool init_zero_ob_size_fails(void* context) {
     BEGIN_TEST;
     Arena arena;
     EXPECT_EQ(ZX_ERR_INVALID_ARGS, arena.Init("name", 0, 16), "");
     END_TEST;
 }

 static bool init_large_ob_size_fails(void* context) {
     BEGIN_TEST;
     Arena arena;
     EXPECT_EQ(ZX_ERR_INVALID_ARGS, arena.Init("name", PAGE_SIZE + 1, 16), "");
     END_TEST;
 }

 static bool init_zero_count_fails(void* context) {
     BEGIN_TEST;
     Arena arena;
     EXPECT_EQ(ZX_ERR_INVALID_ARGS, arena.Init("name", sizeof(TestObj), 0), "");
     END_TEST;
 }

 static bool start_and_end_look_good(void* context) {
     BEGIN_TEST;
     static const size_t num_slots = (2 * PAGE_SIZE) / sizeof(TestObj);
     static const size_t expected_size = num_slots * sizeof(TestObj);

     Arena arena;
     EXPECT_EQ(ZX_OK, arena.Init("name", sizeof(TestObj), num_slots), "");

     EXPECT_NONNULL(arena.start(), "");
     EXPECT_NONNULL(arena.end(), "");
     auto start = reinterpret_cast<vaddr_t>(arena.start());
     auto end = reinterpret_cast<vaddr_t>(arena.end());
     EXPECT_LT(start, end, "");
     EXPECT_GE(end - start, expected_size, "");
     END_TEST;
 }

 static bool in_range_tests(void* context) {
     BEGIN_TEST;
     static const size_t num_slots = (2 * PAGE_SIZE) / sizeof(TestObj);

     Arena arena;
     EXPECT_EQ(ZX_OK, arena.Init("name", sizeof(TestObj), num_slots), "");

     auto start = reinterpret_cast<char*>(arena.start());

     // Nothing is allocated yet, so not even the start address
     // should be in range.
     EXPECT_FALSE(arena.in_range(start), "");

     // Allocate some objects, and check that each is within range.
     static const int nobjs = 16;
     void* objs[nobjs];
     for (int i = 0; i < nobjs; i++) {
         char msg[32];
         snprintf(msg, sizeof(msg), "[%d]", i);
         objs[i] = arena.Alloc();
         EXPECT_NONNULL(objs[i], msg);
         // The allocated object should be in range.
         EXPECT_TRUE(arena.in_range(objs[i]), msg);
         // The slot just after this object should not be in range.
         // FRAGILE: assumes that objects are allocated in increasing order.
         EXPECT_FALSE(
             arena.in_range(reinterpret_cast<TestObj*>(objs[i]) + 1), msg);
         // The count should correspond to the number of times we have
         // allocated.
         EXPECT_EQ(static_cast<size_t>(i + 1), arena.DiagnosticCount(), msg);
     }

     // Deallocate the objects and check whether they're in range.
     for (int i = nobjs - 1; i >= 0; i--) {
         char msg[32];
         snprintf(msg, sizeof(msg), "[%d]", i);
         // The object should still be in range.
         EXPECT_TRUE(arena.in_range(objs[i]), msg);

         arena.Free(objs[i]);

         // The free slot will still be in range.
         // NOTE: If Arena ever learns to coalesce and decommit whole pages of
         // free objects, this test will need to change.
         EXPECT_TRUE(arena.in_range(objs[i]), msg);

         // The count should correspond to the number of times we have
         // deallocated.
         EXPECT_EQ(static_cast<size_t>(i), arena.DiagnosticCount(), msg);
     }
     END_TEST;
 }

 static bool out_of_memory(void* context) {
     BEGIN_TEST;
     static const size_t num_slots = (2 * PAGE_SIZE) / sizeof(TestObj);

     Arena arena;
     EXPECT_EQ(ZX_OK, arena.Init("name", sizeof(TestObj), num_slots), "");

     // Allocate all of the data objects.
     void** objs = reinterpret_cast<void**>(malloc(sizeof(void*) * num_slots));
     void** top = objs;
     for (size_t i = 0; i < num_slots; i++) {
         char msg[32];
         snprintf(msg, sizeof(msg), "[%zu]", i);
         *top++ = arena.Alloc();
         EXPECT_NONNULL(top[-1], msg);
     }

     // Any further allocations should return nullptr.
     EXPECT_NULL(arena.Alloc(), "");
     EXPECT_NULL(arena.Alloc(), "");
     EXPECT_NULL(arena.Alloc(), "");
     EXPECT_NULL(arena.Alloc(), "");

     // Free two objects.
     arena.Free(*--top);
     arena.Free(*--top);

     // Two allocations should succeed; any further should fail.
     *top++ = arena.Alloc();
     EXPECT_NONNULL(top[-1], "");
     *top++ = arena.Alloc();
     EXPECT_NONNULL(top[-1], "");
     EXPECT_NULL(arena.Alloc(), "");
     EXPECT_NULL(arena.Alloc(), "");

     // Free all objects.
     // Nothing much to check except that it doesn't crash.
     while (top > objs) {
         arena.Free(*--top);
     }

     free(objs);
     END_TEST;
 }

 // Test helper. Counts the number of committed and uncommitted pages in the
 // range. Returns {*committed, *uncommitted} = {0, 0} if |start| doesn't
 // correspond to a live VmMapping.
 static bool count_committed_pages(
     vaddr_t start, vaddr_t end, size_t* committed, size_t* uncommitted) {
     BEGIN_TEST; // Not a test, but we need these guards to use REQUIRE_*
     *committed = 0;
     *uncommitted = 0;

     // Find the VmMapping that covers |start|. Assume that it covers |end-1|.
     const auto region = VmAspace::kernel_aspace()->FindRegion(start);
     REQUIRE_NONNULL(region, "FindRegion");
     const auto mapping = region->as_vm_mapping();
     if (mapping == nullptr) {
         // It's a VMAR, not a mapping, so no pages are committed.
         // Return 0/0.
         return true;
     }

     // Ask the VMO how many pages it's allocated within the range.
     auto start_off = ROUNDDOWN(start, PAGE_SIZE) - mapping->base();
     auto end_off = ROUNDUP(end, PAGE_SIZE) - mapping->base();
     *committed = mapping->vmo()->AllocatedPagesInRange(
         start_off + mapping->object_offset(), end_off - start_off);
     *uncommitted = (end_off - start_off) / PAGE_SIZE - *committed;
     END_TEST;
 }

 static bool committing_tests(void* context) {
     BEGIN_TEST;
     static const size_t num_slots = (64 * PAGE_SIZE) / sizeof(TestObj);

     Arena arena;
     EXPECT_EQ(ZX_OK, arena.Init("name", sizeof(TestObj), num_slots), "");

     auto start = reinterpret_cast<vaddr_t>(arena.start());
     auto end = reinterpret_cast<vaddr_t>(arena.end());

     // Nothing is allocated yet, so no pages should be committed.
     size_t committed;
     size_t uncommitted;
     EXPECT_TRUE(
         count_committed_pages(start, end, &committed, &uncommitted), "");
     EXPECT_EQ(0u, committed, "");
     EXPECT_GT(uncommitted, 0u, "");

     // Allocate an object.
     auto obj = reinterpret_cast<vaddr_t>(arena.Alloc());
     EXPECT_NE(0u, obj, "");
     size_t atotal = sizeof(TestObj);

     // The page containing the object should be committed.
     auto ps = ROUNDDOWN(obj, PAGE_SIZE);
     auto pe = ROUNDUP(obj + sizeof(TestObj), PAGE_SIZE);
     EXPECT_TRUE(count_committed_pages(ps, pe, &committed, &uncommitted), "");
     EXPECT_GT(committed, 0u, "");
     EXPECT_EQ(0u, uncommitted, "");

     // The first handful of pages should also become committed, but the rest
     // should stay ucommitted.
     EXPECT_TRUE(
         count_committed_pages(start, end, &committed, &uncommitted), "");
     EXPECT_GT(committed, 0u, "");
     EXPECT_GT(uncommitted, 0u, "");

     // Fill the committed pages with objects; the set of committed pages
     // shouldn't change.
     auto orig_committed = committed;
     auto orig_uncommitted = uncommitted;
     while (atotal + sizeof(TestObj) <= orig_committed * PAGE_SIZE) {
         EXPECT_NONNULL(arena.Alloc(), "");
         atotal += sizeof(TestObj);
     }
     EXPECT_TRUE(
         count_committed_pages(start, end, &committed, &uncommitted), "");
     EXPECT_EQ(orig_committed, committed, "");
     EXPECT_EQ(orig_uncommitted, uncommitted, "");

     // Allocating one more object should cause more pages to be committed.
     EXPECT_NONNULL(arena.Alloc(), "");
     atotal += sizeof(TestObj);
     EXPECT_TRUE(
         count_committed_pages(start, end, &committed, &uncommitted), "");
     EXPECT_LT(orig_committed, committed, "");
     EXPECT_GT(orig_uncommitted, uncommitted, "");

     // TODO(dbort): Test uncommitting if Arena ever learns to decommit pages.
     END_TEST;
 }

 // Friend class that can see inside an Arena.
 namespace fbl {
 class ArenaTestFriend {
 public:
     ArenaTestFriend(const Arena& arena)
         : arena_(arena) {}

     constexpr static size_t control_slot_size() {
         return sizeof(Arena::Node);
     }

     vaddr_t control_start() const {
         return reinterpret_cast<vaddr_t>(arena_.control_.start());
     }

     vaddr_t control_end() const {
         return reinterpret_cast<vaddr_t>(arena_.control_.end());
     }

 private:
     const Arena& arena_;
 };
 } // namespace fbl
 using fbl::ArenaTestFriend;

 // Hit the decommit code path. We can't observe it without peeking inside the
 // control pool, since the data pool doesn't currently decommit.
 static bool uncommitting_tests(void* context) {
     BEGIN_TEST;
     // Create an arena with a 16-page control pool.
     static const size_t num_pages = 16;
     static const size_t num_slots =
         (num_pages * PAGE_SIZE) / ArenaTestFriend::control_slot_size();

     Arena arena;
     // Use a small data slot size (1) to keep our memory usage down.
     EXPECT_EQ(ZX_OK, arena.Init("name", 1, num_slots), "");

     // Get the extent of the control pool.
     vaddr_t start;
     vaddr_t end;
     {
         ArenaTestFriend atf(arena);
         start = reinterpret_cast<vaddr_t>(atf.control_start());
         end = reinterpret_cast<vaddr_t>(atf.control_end());
     }

     // Nothing is allocated yet, so no control pages should be committed.
     size_t committed;
     size_t uncommitted;
     EXPECT_TRUE(
         count_committed_pages(start, end, &committed, &uncommitted), "");
     EXPECT_EQ(num_pages, committed + uncommitted, "");
     EXPECT_EQ(0u, committed, "");
     EXPECT_GT(uncommitted, 0u, "");

     // Allocate all of the data objects. Hold onto the pointers so we can free
     // them.
     void** objs = reinterpret_cast<void**>(malloc(sizeof(void*) * num_slots));
     void** top = objs;
     for (size_t i = 0; i < num_slots; i++) {
         char msg[32];
         snprintf(msg, sizeof(msg), "[%zu]", i);
         *top++ = arena.Alloc();
         EXPECT_NONNULL(top[-1], msg);
     }

     // We still shouldn't see any control pages committed, becase no objects
     // have been freed yet.
     EXPECT_TRUE(
         count_committed_pages(start, end, &committed, &uncommitted), "");
     EXPECT_EQ(num_pages, committed + uncommitted, "");
     EXPECT_EQ(0u, committed, "");
     EXPECT_GT(uncommitted, 0u, "");

     // Demonstrate that we've allocated all of the data objects.
     void* no = arena.Alloc();
     EXPECT_NULL(no, "");

     // Free a data object.
     arena.Free(*--top);

     // We should now see some committed pages inside the control pool.
     EXPECT_TRUE(
         count_committed_pages(start, end, &committed, &uncommitted), "");
     EXPECT_EQ(num_pages, committed + uncommitted, "");
     EXPECT_GT(committed, 0u, "");
     EXPECT_GT(uncommitted, 0u, "");

     // Free all of the data objects.
     while (top > objs) {
         arena.Free(*--top);
     }

     // All of the control pages should be committed.
     EXPECT_TRUE(
         count_committed_pages(start, end, &committed, &uncommitted), "");
     EXPECT_EQ(num_pages, committed + uncommitted, "");
     EXPECT_EQ(committed, num_pages, "");
     EXPECT_EQ(uncommitted, 0u, "");

     // Allocate half of the data objects, freeing up half of the free nodes
     // (and thus half of the control slots).
     auto orig_committed = committed;
     REQUIRE_EQ(top, objs, "");
     for (size_t i = 0; i < num_slots / 2; i++) {
         char msg[32];
         snprintf(msg, sizeof(msg), "[%zu]", i);
         *top++ = arena.Alloc();
         EXPECT_NONNULL(top[-1], msg);
     }

     // The number of committed pages should have dropped.
     EXPECT_TRUE(
         count_committed_pages(start, end, &committed, &uncommitted), "");
     EXPECT_EQ(num_pages, committed + uncommitted, "");
     EXPECT_LT(committed, orig_committed, "");
     EXPECT_GT(uncommitted, 0u, "");

     // Free more control slots (by allocating data objects) until we see more
     // unmapping happen.
     orig_committed = committed;
     for (size_t i = num_slots / 2; i < num_slots; i++) {
         char msg[32];
         snprintf(msg, sizeof(msg), "[%zu]", i);
         *top++ = arena.Alloc();
         EXPECT_NONNULL(top[-1], msg);

         EXPECT_TRUE(
             count_committed_pages(start, end, &committed, &uncommitted), "");
         if (committed != orig_committed) {
             break;
         }
     }
     EXPECT_GT(orig_committed, committed, "");

     // Allocating one more control slot (by freeing a data object) should not
     // cause the number of committed pages to change: there should be some
     // hysteresis built into the system to avoid flickering back and forth.
     orig_committed = committed;
     arena.Free(*--top);
     EXPECT_TRUE(
         count_committed_pages(start, end, &committed, &uncommitted), "");
     EXPECT_EQ(num_pages, committed + uncommitted, "");
     EXPECT_EQ(committed, orig_committed, "");
     EXPECT_GT(uncommitted, 0u, "");

     // Same for freeing a couple more control slots (by allocating more data
     // objects).
     *top++ = arena.Alloc();
     *top++ = arena.Alloc();
     EXPECT_TRUE(
         count_committed_pages(start, end, &committed, &uncommitted), "");
     EXPECT_EQ(num_pages, committed + uncommitted, "");
     EXPECT_EQ(committed, orig_committed, "");
     EXPECT_GT(uncommitted, 0u, "");

     free(objs);
     END_TEST;
 }

 // Checks that destroying an arena unmaps all of its pages.
 static bool memory_cleanup(void* context) {
     BEGIN_TEST;
     static const size_t num_slots = (16 * PAGE_SIZE) / sizeof(TestObj);

     fbl::AllocChecker ac;
     Arena* arena = new (&ac) Arena();
     EXPECT_TRUE(ac.check(), "");
     EXPECT_EQ(ZX_OK, arena->Init("name", sizeof(TestObj), num_slots), "");

     auto start = reinterpret_cast<vaddr_t>(arena->start());
     auto end = reinterpret_cast<vaddr_t>(arena->end());

     // Allocate and leak a bunch of objects.
     for (size_t i = 0; i < num_slots; i++) {
         char msg[32];
         snprintf(msg, sizeof(msg), "[%zu]", i);
         EXPECT_NONNULL(arena->Alloc(), msg);
     }

     // Should see some committed pages.
     size_t committed;
     size_t uncommitted;
     EXPECT_TRUE(
         count_committed_pages(start, end, &committed, &uncommitted), "");
     EXPECT_GT(committed, 0u, "");

     // Destroying the Arena should destroy the underlying VmMapping,
     // along with all of its pages.
     delete arena;
     EXPECT_TRUE(
         count_committed_pages(start, end, &committed, &uncommitted), "");
     // 0/0 means "no mapping at this address".
     // FLAKY: Another thread could could come in and allocate a mapping at the
     // old location.
     EXPECT_EQ(committed, 0u, "");
     EXPECT_EQ(uncommitted, 0u, "");
     END_TEST;
 }

 // Basic checks that the contents of allocated objects stick around, aren't
 // stomped on.
 static bool content_preservation(void* context) {
     BEGIN_TEST;
     Arena arena;
     zx_status_t s = arena.Init("arena_tests", sizeof(TestObj), 1000);
     REQUIRE_EQ(ZX_OK, s, "arena.Init()");

     const int count = 30;

     for (int times = 0; times != 5; ++times) {
         TestObj* afp[count] = {0};

         for (int ix = 0; ix != count; ++ix) {
             afp[ix] = reinterpret_cast<TestObj*>(arena.Alloc());
             REQUIRE_NONNULL(afp[ix], "arena.Alloc()");
             *afp[ix] = {17, 5, ix + 100};
         }

         arena.Free(afp[3]);
         arena.Free(afp[4]);
         arena.Free(afp[5]);
         afp[3] = afp[4] = afp[5] = nullptr;

         afp[4] = reinterpret_cast<TestObj*>(arena.Alloc());
         REQUIRE_NONNULL(afp[4], "arena.Alloc()");
         *afp[4] = {17, 5, 104};

         for (int ix = 0; ix != count; ++ix) {
             if (!afp[ix])
                 continue;

             EXPECT_EQ(17, afp[ix]->xx, "");
             EXPECT_EQ(5, afp[ix]->yy, "");
             EXPECT_EQ(ix + 100, afp[ix]->zz, "");

             arena.Free(afp[ix]);
         }

         // Leak a few objects.
         for (int ix = 0; ix != 7; ++ix) {
             TestObj* leak = reinterpret_cast<TestObj*>(arena.Alloc());
             REQUIRE_NONNULL(leak, "arena.Alloc()");
             *leak = {2121, 77, 55};
         }
     }
     END_TEST;
 }

 #define ARENA_UNITTEST(fname) UNITTEST(#fname, fname)

 UNITTEST_START_TESTCASE(arena_tests)
 ARENA_UNITTEST(init_null_name_succeeds)
 ARENA_UNITTEST(init_zero_ob_size_fails)
 ARENA_UNITTEST(init_large_ob_size_fails)
 ARENA_UNITTEST(init_zero_count_fails)
 ARENA_UNITTEST(start_and_end_look_good)
 ARENA_UNITTEST(in_range_tests)
 ARENA_UNITTEST(out_of_memory)
 ARENA_UNITTEST(committing_tests)
 ARENA_UNITTEST(uncommitting_tests)
 ARENA_UNITTEST(memory_cleanup)
 ARENA_UNITTEST(content_preservation)
 UNITTEST_END_TESTCASE(arena_tests, "arenatests", "Arena allocator test", nullptr, nullptr);
	// Copyright 2016 The Fuchsia Authors
	//
	// Use of this source code is governed by a MIT-style
	// license that can be found in the LICENSE file or at
	// https://opensource.org/licenses/MIT

	#include <fbl/arena.h>

	#include <vm/vm_aspace.h>
	#include <fbl/alloc_checker.h>
	#include <unittest.h>

	using fbl::Arena;

	struct TestObj {
	int xx, yy, zz;
	};

	static bool init_null_name_succeeds(void* context) {
	BEGIN_TEST;
	Arena arena;
	EXPECT_EQ(ZX_OK, arena.Init(nullptr, sizeof(TestObj), 16), "");
	END_TEST;
	}

	static bool init_zero_ob_size_fails(void* context) {
	BEGIN_TEST;
	Arena arena;
	EXPECT_EQ(ZX_ERR_INVALID_ARGS, arena.Init("name", 0, 16), "");
	END_TEST;
	}

	static bool init_large_ob_size_fails(void* context) {
	BEGIN_TEST;
	Arena arena;
	EXPECT_EQ(ZX_ERR_INVALID_ARGS, arena.Init("name", PAGE_SIZE + 1, 16), "");
	END_TEST;
	}

	static bool init_zero_count_fails(void* context) {
	BEGIN_TEST;
	Arena arena;
	EXPECT_EQ(ZX_ERR_INVALID_ARGS, arena.Init("name", sizeof(TestObj), 0), "");
	END_TEST;
	}

	static bool start_and_end_look_good(void* context) {
	BEGIN_TEST;
	static const size_t num_slots = (2 * PAGE_SIZE) / sizeof(TestObj);
	static const size_t expected_size = num_slots * sizeof(TestObj);

	Arena arena;
	EXPECT_EQ(ZX_OK, arena.Init("name", sizeof(TestObj), num_slots), "");

	EXPECT_NONNULL(arena.start(), "");
	EXPECT_NONNULL(arena.end(), "");
	auto start = reinterpret_cast<vaddr_t>(arena.start());
	auto end = reinterpret_cast<vaddr_t>(arena.end());
	EXPECT_LT(start, end, "");
	EXPECT_GE(end - start, expected_size, "");
	END_TEST;
	}

	static bool in_range_tests(void* context) {
	BEGIN_TEST;
	static const size_t num_slots = (2 * PAGE_SIZE) / sizeof(TestObj);

	Arena arena;
	EXPECT_EQ(ZX_OK, arena.Init("name", sizeof(TestObj), num_slots), "");

	auto start = reinterpret_cast<char*>(arena.start());

	// Nothing is allocated yet, so not even the start address
	// should be in range.
	EXPECT_FALSE(arena.in_range(start), "");

	// Allocate some objects, and check that each is within range.
	static const int nobjs = 16;
	void* objs[nobjs];
	for (int i = 0; i < nobjs; i++) {
	char msg[32];
	snprintf(msg, sizeof(msg), "[%d]", i);
	objs[i] = arena.Alloc();
	EXPECT_NONNULL(objs[i], msg);
	// The allocated object should be in range.
	EXPECT_TRUE(arena.in_range(objs[i]), msg);
	// The slot just after this object should not be in range.
	// FRAGILE: assumes that objects are allocated in increasing order.
	EXPECT_FALSE(
	arena.in_range(reinterpret_cast<TestObj*>(objs[i]) + 1), msg);
	// The count should correspond to the number of times we have
	// allocated.
	EXPECT_EQ(static_cast<size_t>(i + 1), arena.DiagnosticCount(), msg);
	}

	// Deallocate the objects and check whether they're in range.
	for (int i = nobjs - 1; i >= 0; i--) {
	char msg[32];
	snprintf(msg, sizeof(msg), "[%d]", i);
	// The object should still be in range.
	EXPECT_TRUE(arena.in_range(objs[i]), msg);

	arena.Free(objs[i]);

	// The free slot will still be in range.
	// NOTE: If Arena ever learns to coalesce and decommit whole pages of
	// free objects, this test will need to change.
	EXPECT_TRUE(arena.in_range(objs[i]), msg);

	// The count should correspond to the number of times we have
	// deallocated.
	EXPECT_EQ(static_cast<size_t>(i), arena.DiagnosticCount(), msg);
	}
	END_TEST;
	}

	static bool out_of_memory(void* context) {
	BEGIN_TEST;
	static const size_t num_slots = (2 * PAGE_SIZE) / sizeof(TestObj);

	Arena arena;
	EXPECT_EQ(ZX_OK, arena.Init("name", sizeof(TestObj), num_slots), "");

	// Allocate all of the data objects.
	void objs = reinterpret_cast<void>(malloc(sizeof(void) num_slots));
	void** top = objs;
	for (size_t i = 0; i < num_slots; i++) {
	char msg[32];
	snprintf(msg, sizeof(msg), "[%zu]", i);
	*top++ = arena.Alloc();
	EXPECT_NONNULL(top[-1], msg);
	}

	// Any further allocations should return nullptr.
	EXPECT_NULL(arena.Alloc(), "");
	EXPECT_NULL(arena.Alloc(), "");
	EXPECT_NULL(arena.Alloc(), "");
	EXPECT_NULL(arena.Alloc(), "");

	// Free two objects.
	arena.Free(*--top);
	arena.Free(*--top);

	// Two allocations should succeed; any further should fail.
	*top++ = arena.Alloc();
	EXPECT_NONNULL(top[-1], "");
	*top++ = arena.Alloc();
	EXPECT_NONNULL(top[-1], "");
	EXPECT_NULL(arena.Alloc(), "");
	EXPECT_NULL(arena.Alloc(), "");

	// Free all objects.
	// Nothing much to check except that it doesn't crash.
	while (top > objs) {
	arena.Free(*--top);
	}

	free(objs);
	END_TEST;
	}

	// Test helper. Counts the number of committed and uncommitted pages in the
	// range. Returns {committed, uncommitted} = {0, 0} if \|start\| doesn't
	// correspond to a live VmMapping.
	static bool count_committed_pages(
	vaddr_t start, vaddr_t end, size_t* committed, size_t* uncommitted) {
	BEGIN_TEST; // Not a test, but we need these guards to use REQUIRE_*
	*committed = 0;
	*uncommitted = 0;

	// Find the VmMapping that covers \|start\|. Assume that it covers \|end-1\|.
	const auto region = VmAspace::kernel_aspace()->FindRegion(start);
	REQUIRE_NONNULL(region, "FindRegion");
	const auto mapping = region->as_vm_mapping();
	if (mapping == nullptr) {
	// It's a VMAR, not a mapping, so no pages are committed.
	// Return 0/0.
	return true;
	}

	// Ask the VMO how many pages it's allocated within the range.
	auto start_off = ROUNDDOWN(start, PAGE_SIZE) - mapping->base();
	auto end_off = ROUNDUP(end, PAGE_SIZE) - mapping->base();
	*committed = mapping->vmo()->AllocatedPagesInRange(
	start_off + mapping->object_offset(), end_off - start_off);
	uncommitted = (end_off - start_off) / PAGE_SIZE - committed;
	END_TEST;
	}

	static bool committing_tests(void* context) {
	BEGIN_TEST;
	static const size_t num_slots = (64 * PAGE_SIZE) / sizeof(TestObj);

	Arena arena;
	EXPECT_EQ(ZX_OK, arena.Init("name", sizeof(TestObj), num_slots), "");

	auto start = reinterpret_cast<vaddr_t>(arena.start());
	auto end = reinterpret_cast<vaddr_t>(arena.end());

	// Nothing is allocated yet, so no pages should be committed.
	size_t committed;
	size_t uncommitted;
	EXPECT_TRUE(
	count_committed_pages(start, end, &committed, &uncommitted), "");
	EXPECT_EQ(0u, committed, "");
	EXPECT_GT(uncommitted, 0u, "");

	// Allocate an object.
	auto obj = reinterpret_cast<vaddr_t>(arena.Alloc());
	EXPECT_NE(0u, obj, "");
	size_t atotal = sizeof(TestObj);

	// The page containing the object should be committed.
	auto ps = ROUNDDOWN(obj, PAGE_SIZE);
	auto pe = ROUNDUP(obj + sizeof(TestObj), PAGE_SIZE);
	EXPECT_TRUE(count_committed_pages(ps, pe, &committed, &uncommitted), "");
	EXPECT_GT(committed, 0u, "");
	EXPECT_EQ(0u, uncommitted, "");

	// The first handful of pages should also become committed, but the rest
	// should stay ucommitted.
	EXPECT_TRUE(
	count_committed_pages(start, end, &committed, &uncommitted), "");
	EXPECT_GT(committed, 0u, "");
	EXPECT_GT(uncommitted, 0u, "");

	// Fill the committed pages with objects; the set of committed pages
	// shouldn't change.
	auto orig_committed = committed;
	auto orig_uncommitted = uncommitted;
	while (atotal + sizeof(TestObj) <= orig_committed * PAGE_SIZE) {
	EXPECT_NONNULL(arena.Alloc(), "");
	atotal += sizeof(TestObj);
	}
	EXPECT_TRUE(
	count_committed_pages(start, end, &committed, &uncommitted), "");
	EXPECT_EQ(orig_committed, committed, "");
	EXPECT_EQ(orig_uncommitted, uncommitted, "");

	// Allocating one more object should cause more pages to be committed.
	EXPECT_NONNULL(arena.Alloc(), "");
	atotal += sizeof(TestObj);
	EXPECT_TRUE(
	count_committed_pages(start, end, &committed, &uncommitted), "");
	EXPECT_LT(orig_committed, committed, "");
	EXPECT_GT(orig_uncommitted, uncommitted, "");

	// TODO(dbort): Test uncommitting if Arena ever learns to decommit pages.
	END_TEST;
	}

	// Friend class that can see inside an Arena.
	namespace fbl {
	class ArenaTestFriend {
	public:
	ArenaTestFriend(const Arena& arena)
	: arena_(arena) {}

	constexpr static size_t control_slot_size() {
	return sizeof(Arena::Node);
	}

	vaddr_t control_start() const {
	return reinterpret_cast<vaddr_t>(arena_.control_.start());
	}

	vaddr_t control_end() const {
	return reinterpret_cast<vaddr_t>(arena_.control_.end());
	}

	private:
	const Arena& arena_;
	};
	} // namespace fbl
	using fbl::ArenaTestFriend;

	// Hit the decommit code path. We can't observe it without peeking inside the
	// control pool, since the data pool doesn't currently decommit.
	static bool uncommitting_tests(void* context) {
	BEGIN_TEST;
	// Create an arena with a 16-page control pool.
	static const size_t num_pages = 16;
	static const size_t num_slots =
	(num_pages * PAGE_SIZE) / ArenaTestFriend::control_slot_size();

	Arena arena;
	// Use a small data slot size (1) to keep our memory usage down.
	EXPECT_EQ(ZX_OK, arena.Init("name", 1, num_slots), "");

	// Get the extent of the control pool.
	vaddr_t start;
	vaddr_t end;
	{
	ArenaTestFriend atf(arena);
	start = reinterpret_cast<vaddr_t>(atf.control_start());
	end = reinterpret_cast<vaddr_t>(atf.control_end());
	}

	// Nothing is allocated yet, so no control pages should be committed.
	size_t committed;
	size_t uncommitted;
	EXPECT_TRUE(
	count_committed_pages(start, end, &committed, &uncommitted), "");
	EXPECT_EQ(num_pages, committed + uncommitted, "");
	EXPECT_EQ(0u, committed, "");
	EXPECT_GT(uncommitted, 0u, "");

	// Allocate all of the data objects. Hold onto the pointers so we can free
	// them.
	void objs = reinterpret_cast<void>(malloc(sizeof(void) num_slots));
	void** top = objs;
	for (size_t i = 0; i < num_slots; i++) {
	char msg[32];
	snprintf(msg, sizeof(msg), "[%zu]", i);
	*top++ = arena.Alloc();
	EXPECT_NONNULL(top[-1], msg);
	}

	// We still shouldn't see any control pages committed, becase no objects
	// have been freed yet.
	EXPECT_TRUE(
	count_committed_pages(start, end, &committed, &uncommitted), "");
	EXPECT_EQ(num_pages, committed + uncommitted, "");
	EXPECT_EQ(0u, committed, "");
	EXPECT_GT(uncommitted, 0u, "");

	// Demonstrate that we've allocated all of the data objects.
	void* no = arena.Alloc();
	EXPECT_NULL(no, "");

	// Free a data object.
	arena.Free(*--top);

	// We should now see some committed pages inside the control pool.
	EXPECT_TRUE(
	count_committed_pages(start, end, &committed, &uncommitted), "");
	EXPECT_EQ(num_pages, committed + uncommitted, "");
	EXPECT_GT(committed, 0u, "");
	EXPECT_GT(uncommitted, 0u, "");

	// Free all of the data objects.
	while (top > objs) {
	arena.Free(*--top);
	}

	// All of the control pages should be committed.
	EXPECT_TRUE(
	count_committed_pages(start, end, &committed, &uncommitted), "");
	EXPECT_EQ(num_pages, committed + uncommitted, "");
	EXPECT_EQ(committed, num_pages, "");
	EXPECT_EQ(uncommitted, 0u, "");

	// Allocate half of the data objects, freeing up half of the free nodes
	// (and thus half of the control slots).
	auto orig_committed = committed;
	REQUIRE_EQ(top, objs, "");
	for (size_t i = 0; i < num_slots / 2; i++) {
	char msg[32];
	snprintf(msg, sizeof(msg), "[%zu]", i);
	*top++ = arena.Alloc();
	EXPECT_NONNULL(top[-1], msg);
	}

	// The number of committed pages should have dropped.
	EXPECT_TRUE(
	count_committed_pages(start, end, &committed, &uncommitted), "");
	EXPECT_EQ(num_pages, committed + uncommitted, "");
	EXPECT_LT(committed, orig_committed, "");
	EXPECT_GT(uncommitted, 0u, "");

	// Free more control slots (by allocating data objects) until we see more
	// unmapping happen.
	orig_committed = committed;
	for (size_t i = num_slots / 2; i < num_slots; i++) {
	char msg[32];
	snprintf(msg, sizeof(msg), "[%zu]", i);
	*top++ = arena.Alloc();
	EXPECT_NONNULL(top[-1], msg);

	EXPECT_TRUE(
	count_committed_pages(start, end, &committed, &uncommitted), "");
	if (committed != orig_committed) {
	break;
	}
	}
	EXPECT_GT(orig_committed, committed, "");

	// Allocating one more control slot (by freeing a data object) should not
	// cause the number of committed pages to change: there should be some
	// hysteresis built into the system to avoid flickering back and forth.
	orig_committed = committed;
	arena.Free(*--top);
	EXPECT_TRUE(
	count_committed_pages(start, end, &committed, &uncommitted), "");
	EXPECT_EQ(num_pages, committed + uncommitted, "");
	EXPECT_EQ(committed, orig_committed, "");
	EXPECT_GT(uncommitted, 0u, "");

	// Same for freeing a couple more control slots (by allocating more data
	// objects).
	*top++ = arena.Alloc();
	*top++ = arena.Alloc();
	EXPECT_TRUE(
	count_committed_pages(start, end, &committed, &uncommitted), "");
	EXPECT_EQ(num_pages, committed + uncommitted, "");
	EXPECT_EQ(committed, orig_committed, "");
	EXPECT_GT(uncommitted, 0u, "");

	free(objs);
	END_TEST;
	}

	// Checks that destroying an arena unmaps all of its pages.
	static bool memory_cleanup(void* context) {
	BEGIN_TEST;
	static const size_t num_slots = (16 * PAGE_SIZE) / sizeof(TestObj);

	fbl::AllocChecker ac;
	Arena* arena = new (&ac) Arena();
	EXPECT_TRUE(ac.check(), "");
	EXPECT_EQ(ZX_OK, arena->Init("name", sizeof(TestObj), num_slots), "");

	auto start = reinterpret_cast<vaddr_t>(arena->start());
	auto end = reinterpret_cast<vaddr_t>(arena->end());

	// Allocate and leak a bunch of objects.
	for (size_t i = 0; i < num_slots; i++) {
	char msg[32];
	snprintf(msg, sizeof(msg), "[%zu]", i);
	EXPECT_NONNULL(arena->Alloc(), msg);
	}

	// Should see some committed pages.
	size_t committed;
	size_t uncommitted;
	EXPECT_TRUE(
	count_committed_pages(start, end, &committed, &uncommitted), "");
	EXPECT_GT(committed, 0u, "");

	// Destroying the Arena should destroy the underlying VmMapping,
	// along with all of its pages.
	delete arena;
	EXPECT_TRUE(
	count_committed_pages(start, end, &committed, &uncommitted), "");
	// 0/0 means "no mapping at this address".
	// FLAKY: Another thread could could come in and allocate a mapping at the
	// old location.
	EXPECT_EQ(committed, 0u, "");
	EXPECT_EQ(uncommitted, 0u, "");
	END_TEST;
	}

	// Basic checks that the contents of allocated objects stick around, aren't
	// stomped on.
	static bool content_preservation(void* context) {
	BEGIN_TEST;
	Arena arena;
	zx_status_t s = arena.Init("arena_tests", sizeof(TestObj), 1000);
	REQUIRE_EQ(ZX_OK, s, "arena.Init()");

	const int count = 30;

	for (int times = 0; times != 5; ++times) {
	TestObj* afp[count] = {0};

	for (int ix = 0; ix != count; ++ix) {
	afp[ix] = reinterpret_cast<TestObj*>(arena.Alloc());
	REQUIRE_NONNULL(afp[ix], "arena.Alloc()");
	*afp[ix] = {17, 5, ix + 100};
	}

	arena.Free(afp[3]);
	arena.Free(afp[4]);
	arena.Free(afp[5]);
	afp[3] = afp[4] = afp[5] = nullptr;

	afp[4] = reinterpret_cast<TestObj*>(arena.Alloc());
	REQUIRE_NONNULL(afp[4], "arena.Alloc()");
	*afp[4] = {17, 5, 104};

	for (int ix = 0; ix != count; ++ix) {
	if (!afp[ix])
	continue;

	EXPECT_EQ(17, afp[ix]->xx, "");
	EXPECT_EQ(5, afp[ix]->yy, "");
	EXPECT_EQ(ix + 100, afp[ix]->zz, "");

	arena.Free(afp[ix]);
	}

	// Leak a few objects.
	for (int ix = 0; ix != 7; ++ix) {
	TestObj* leak = reinterpret_cast<TestObj*>(arena.Alloc());
	REQUIRE_NONNULL(leak, "arena.Alloc()");
	*leak = {2121, 77, 55};
	}
	}
	END_TEST;
	}

	#define ARENA_UNITTEST(fname) UNITTEST(#fname, fname)

	UNITTEST_START_TESTCASE(arena_tests)
	ARENA_UNITTEST(init_null_name_succeeds)
	ARENA_UNITTEST(init_zero_ob_size_fails)
	ARENA_UNITTEST(init_large_ob_size_fails)
	ARENA_UNITTEST(init_zero_count_fails)
	ARENA_UNITTEST(start_and_end_look_good)
	ARENA_UNITTEST(in_range_tests)
	ARENA_UNITTEST(out_of_memory)
	ARENA_UNITTEST(committing_tests)
	ARENA_UNITTEST(uncommitting_tests)
	ARENA_UNITTEST(memory_cleanup)
	ARENA_UNITTEST(content_preservation)
	UNITTEST_END_TESTCASE(arena_tests, "arenatests", "Arena allocator test", nullptr, nullptr);