tests/GrMemoryPoolTest.cpp - skia.git - Git at Google

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */

 #include "Test.h"
 // This is a GPU-backend specific test
 #if SK_SUPPORT_GPU
 #include "GrMemoryPool.h"
 #include "SkRandom.h"
 #include "SkTArray.h"
 #include "SkTDArray.h"
 #include "SkTemplates.h"

 // A is the top of an inheritance tree of classes that overload op new and
 // and delete to use a GrMemoryPool. The objects have values of different types
 // that can be set and checked.
 class A {
 public:
     A() {}
     virtual void setValues(int v) {
         fChar = static_cast<char>(v);
     }
     virtual bool checkValues(int v) {
         return fChar == static_cast<char>(v);
     }
     virtual ~A() {}

     void* operator new(size_t size) {
         if (!gPool.get()) {
             return ::operator new(size);
         } else {
             return gPool->allocate(size);
         }
     }

     void operator delete(void* p) {
         if (!gPool.get()) {
             ::operator delete(p);
         } else {
             return gPool->release(p);
         }
     }

     static A* Create(SkRandom* r);

     static void SetAllocator(size_t preallocSize, size_t minAllocSize) {
         GrMemoryPool* pool = new GrMemoryPool(preallocSize, minAllocSize);
         gPool.reset(pool);
     }

     static void ResetAllocator() {
         gPool.reset(nullptr);
     }

 private:
     static std::unique_ptr<GrMemoryPool> gPool;
     char fChar;
 };

 std::unique_ptr<GrMemoryPool> A::gPool;

 class B : public A {
 public:
     B() {}
     virtual void setValues(int v) {
         fDouble = static_cast<double>(v);
         this->INHERITED::setValues(v);
     }
     virtual bool checkValues(int v) {
         return fDouble == static_cast<double>(v) &&
                this->INHERITED::checkValues(v);
     }
     virtual ~B() {}

 private:
     double fDouble;

     typedef A INHERITED;
 };

 class C : public A {
 public:
     C() {}
     virtual void setValues(int v) {
         fInt64 = static_cast<int64_t>(v);
         this->INHERITED::setValues(v);
     }
     virtual bool checkValues(int v) {
         return fInt64 == static_cast<int64_t>(v) &&
                this->INHERITED::checkValues(v);
     }
     virtual ~C() {}

 private:
     int64_t fInt64;

     typedef A INHERITED;
 };

 // D derives from C and owns a dynamically created B
 class D : public C {
 public:
     D() {
         fB = new B();
     }
     virtual void setValues(int v) {
         fVoidStar = reinterpret_cast<void*>(static_cast<intptr_t>(v));
         this->INHERITED::setValues(v);
         fB->setValues(v);
     }
     virtual bool checkValues(int v) {
         return fVoidStar == reinterpret_cast<void*>(static_cast<intptr_t>(v)) &&
                fB->checkValues(v) &&
                this->INHERITED::checkValues(v);
     }
     virtual ~D() {
         delete fB;
     }
 private:
     void*   fVoidStar;
     B*      fB;

     typedef C INHERITED;
 };

 class E : public A {
 public:
     E() {}
     virtual void setValues(int v) {
         for (size_t i = 0; i < SK_ARRAY_COUNT(fIntArray); ++i) {
             fIntArray[i] = v;
         }
         this->INHERITED::setValues(v);
     }
     virtual bool checkValues(int v) {
         bool ok = true;
         for (size_t i = 0; ok && i < SK_ARRAY_COUNT(fIntArray); ++i) {
             if (fIntArray[i] != v) {
                 ok = false;
             }
         }
         return ok && this->INHERITED::checkValues(v);
     }
     virtual ~E() {}
 private:
     int   fIntArray[20];

     typedef A INHERITED;
 };

 A* A::Create(SkRandom* r) {
     switch (r->nextRangeU(0, 4)) {
         case 0:
             return new A;
         case 1:
             return new B;
         case 2:
             return new C;
         case 3:
             return new D;
         case 4:
             return new E;
         default:
             // suppress warning
             return nullptr;
     }
 }

 struct Rec {
     A* fInstance;
     int fValue;
 };

 DEF_TEST(GrMemoryPool, reporter) {
     // prealloc and min alloc sizes for the pool
     static const size_t gSizes[][2] = {
         {0, 0},
         {10 * sizeof(A), 20 * sizeof(A)},
         {100 * sizeof(A), 100 * sizeof(A)},
         {500 * sizeof(A), 500 * sizeof(A)},
         {10000 * sizeof(A), 0},
         {1, 100 * sizeof(A)},
     };
     // different percentages of creation vs deletion
     static const float gCreateFraction[] = {1.f, .95f, 0.75f, .5f};
     // number of create/destroys per test
     static const int kNumIters = 20000;
     // check that all the values stored in A objects are correct after this
     // number of iterations
     static const int kCheckPeriod = 500;

     SkRandom r;
     for (size_t s = 0; s < SK_ARRAY_COUNT(gSizes); ++s) {
         A::SetAllocator(gSizes[s][0], gSizes[s][1]);
         for (size_t c = 0; c < SK_ARRAY_COUNT(gCreateFraction); ++c) {
             SkTDArray<Rec> instanceRecs;
             for (int i = 0; i < kNumIters; ++i) {
                 float createOrDestroy = r.nextUScalar1();
                 if (createOrDestroy < gCreateFraction[c] ||
                     0 == instanceRecs.count()) {
                     Rec* rec = instanceRecs.append();
                     rec->fInstance = A::Create(&r);
                     rec->fValue = static_cast<int>(r.nextU());
                     rec->fInstance->setValues(rec->fValue);
                 } else {
                     int d = r.nextRangeU(0, instanceRecs.count() - 1);
                     Rec& rec = instanceRecs[d];
                     REPORTER_ASSERT(reporter, rec.fInstance->checkValues(rec.fValue));
                     delete rec.fInstance;
                     instanceRecs.removeShuffle(d);
                 }
                 if (0 == i % kCheckPeriod) {
                     for (int r = 0; r < instanceRecs.count(); ++r) {
                         Rec& rec = instanceRecs[r];
                         REPORTER_ASSERT(reporter, rec.fInstance->checkValues(rec.fValue));
                     }
                 }
             }
             for (int i = 0; i < instanceRecs.count(); ++i) {
                 Rec& rec = instanceRecs[i];
                 REPORTER_ASSERT(reporter, rec.fInstance->checkValues(rec.fValue));
                 delete rec.fInstance;
             }
         }
     }
 }

 // GrMemoryPool requires that it's empty at the point of destruction. This helps
 // achieving that by releasing all added memory in the destructor.
 class AutoPoolReleaser {
 public:
     AutoPoolReleaser(GrMemoryPool& pool): fPool(pool) {
     }
     ~AutoPoolReleaser() {
         for (void* ptr: fAllocated) {
             fPool.release(ptr);
         }
     }
     void add(void* ptr) {
         fAllocated.push_back(ptr);
     }
 private:
     GrMemoryPool& fPool;
     SkTArray<void*> fAllocated;
 };

 DEF_TEST(GrMemoryPoolAPI, reporter) {
     constexpr size_t kSmallestMinAllocSize = GrMemoryPool::kSmallestMinAllocSize;

     // Allocates memory until pool adds a new block (pool.size() changes).
     auto allocateMemory = [](GrMemoryPool& pool, AutoPoolReleaser& r) {
         size_t origPoolSize = pool.size();
         while (pool.size() == origPoolSize) {
             r.add(pool.allocate(31));
         }
     };

     // Effective prealloc space capacity is >= kSmallestMinAllocSize.
     {
         GrMemoryPool pool(0, 0);
         REPORTER_ASSERT(reporter, pool.preallocSize() == kSmallestMinAllocSize);
     }

     // Effective prealloc space capacity is >= minAllocSize.
     {
         constexpr size_t kMinAllocSize = kSmallestMinAllocSize * 2;
         GrMemoryPool pool(kSmallestMinAllocSize, kMinAllocSize);
         REPORTER_ASSERT(reporter, pool.preallocSize() == kMinAllocSize);
     }

     // Effective block size capacity >= kSmallestMinAllocSize.
     {
         GrMemoryPool pool(kSmallestMinAllocSize, kSmallestMinAllocSize / 2);
         AutoPoolReleaser r(pool);

         allocateMemory(pool, r);
         REPORTER_ASSERT(reporter, pool.size() == kSmallestMinAllocSize);
     }

     // Pool allocates exactly preallocSize on creation.
     {
         constexpr size_t kPreallocSize = kSmallestMinAllocSize * 5;
         GrMemoryPool pool(kPreallocSize, 0);
         REPORTER_ASSERT(reporter, pool.preallocSize() == kPreallocSize);
     }

     // Pool allocates exactly minAllocSize when it expands.
     {
         constexpr size_t kMinAllocSize = kSmallestMinAllocSize * 7;
         GrMemoryPool pool(0, kMinAllocSize);
         AutoPoolReleaser r(pool);

         allocateMemory(pool, r);
         REPORTER_ASSERT(reporter, pool.size() == kMinAllocSize);

         allocateMemory(pool, r);
         REPORTER_ASSERT(reporter, pool.size() == 2 * kMinAllocSize);
     }

     // When asked to allocate amount > minAllocSize, pool allocates larger block
     // to accommodate all internal structures.
     {
         constexpr size_t kMinAllocSize = kSmallestMinAllocSize * 2;
         GrMemoryPool pool(kSmallestMinAllocSize, kMinAllocSize);
         AutoPoolReleaser r(pool);

         REPORTER_ASSERT(reporter, pool.size() == 0);

         constexpr size_t hugeSize = 10 * kMinAllocSize;
         r.add(pool.allocate(hugeSize));
         REPORTER_ASSERT(reporter, pool.size() > hugeSize);

         // Block size allocated to accommodate huge request doesn't include any extra
         // space, so next allocation request allocates a new block.
         size_t hugeBlockSize = pool.size();
         r.add(pool.allocate(0));
         REPORTER_ASSERT(reporter, pool.size() == hugeBlockSize + kMinAllocSize);
     }
 }

 DEF_TEST(GrObjectMemoryPoolAPI, reporter) {
     struct Data {
         int value[5];
     };
     using DataObjectPool = GrObjectMemoryPool<Data>;
     constexpr size_t kSmallestMinAllocCount = DataObjectPool::kSmallestMinAllocCount;

     // Allocates objects until pool adds a new block (pool.size() changes).
     // Returns number of objects that fit into the current block (i.e. before pool.size()
     // changed; newly allocated block always ends up with one object allocated from it).
     auto allocateObjects = [](DataObjectPool& pool, AutoPoolReleaser& r) -> size_t {
         size_t count = 0;
         size_t origPoolSize = pool.size();
         while (pool.size() == origPoolSize) {
             r.add(pool.allocate());
             count++;
         }
         return count - 1;
     };

     // Effective prealloc space capacity is >= kSmallestMinAllocCount.
     {
         DataObjectPool pool(kSmallestMinAllocCount / 3, 0);
         AutoPoolReleaser r(pool);

         size_t preallocCount = allocateObjects(pool, r);
         REPORTER_ASSERT(reporter, preallocCount == kSmallestMinAllocCount);
     }

     // Effective prealloc space capacity is >= minAllocCount.
     {
         DataObjectPool pool(kSmallestMinAllocCount, 2 * kSmallestMinAllocCount);
         AutoPoolReleaser r(pool);

         size_t preallocCount = allocateObjects(pool, r);
         REPORTER_ASSERT(reporter, preallocCount == 2 * kSmallestMinAllocCount);
     }

     // Effective block capacity is >= kSmallestMinAllocCount.
     {
         DataObjectPool pool(kSmallestMinAllocCount, kSmallestMinAllocCount / 2);
         AutoPoolReleaser r(pool);

         // Fill prealloc space
         allocateObjects(pool, r);

         size_t minAllocCount = 1 + allocateObjects(pool, r);
         REPORTER_ASSERT(reporter, minAllocCount == kSmallestMinAllocCount);
     }

     // Pool allocates space for exactly preallocCount objects on creation.
     {
         constexpr size_t kPreallocCount = kSmallestMinAllocCount * 7 / 3;
         DataObjectPool pool(kPreallocCount, 0);
         AutoPoolReleaser r(pool);

         size_t preallocCount = allocateObjects(pool, r);
         REPORTER_ASSERT(reporter, preallocCount == kPreallocCount);
     }

     // Pool allocates space for minAllocCount objects when it adds a new block.
     {
         constexpr size_t kMinAllocCount = kSmallestMinAllocCount * 11 / 3;
         DataObjectPool pool(0, kMinAllocCount);
         AutoPoolReleaser r(pool);

         // Fill prealloc space
         allocateObjects(pool, r);

         size_t firstBlockCount = 1 + allocateObjects(pool, r);
         REPORTER_ASSERT(reporter, firstBlockCount == kMinAllocCount);

         size_t secondBlockCount = 1 + allocateObjects(pool, r);
         REPORTER_ASSERT(reporter, secondBlockCount == kMinAllocCount);
     }
 }

 #endif
	/*
	* Copyright 2011 Google Inc.
	*
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#include "Test.h"
	// This is a GPU-backend specific test
	#if SK_SUPPORT_GPU
	#include "GrMemoryPool.h"
	#include "SkRandom.h"
	#include "SkTArray.h"
	#include "SkTDArray.h"
	#include "SkTemplates.h"

	// A is the top of an inheritance tree of classes that overload op new and
	// and delete to use a GrMemoryPool. The objects have values of different types
	// that can be set and checked.
	class A {
	public:
	A() {}
	virtual void setValues(int v) {
	fChar = static_cast<char>(v);
	}
	virtual bool checkValues(int v) {
	return fChar == static_cast<char>(v);
	}
	virtual ~A() {}

	void* operator new(size_t size) {
	if (!gPool.get()) {
	return ::operator new(size);
	} else {
	return gPool->allocate(size);
	}
	}

	void operator delete(void* p) {
	if (!gPool.get()) {
	::operator delete(p);
	} else {
	return gPool->release(p);
	}
	}

	static A* Create(SkRandom* r);

	static void SetAllocator(size_t preallocSize, size_t minAllocSize) {
	GrMemoryPool* pool = new GrMemoryPool(preallocSize, minAllocSize);
	gPool.reset(pool);
	}

	static void ResetAllocator() {
	gPool.reset(nullptr);
	}

	private:
	static std::unique_ptr<GrMemoryPool> gPool;
	char fChar;
	};

	std::unique_ptr<GrMemoryPool> A::gPool;

	class B : public A {
	public:
	B() {}
	virtual void setValues(int v) {
	fDouble = static_cast<double>(v);
	this->INHERITED::setValues(v);
	}
	virtual bool checkValues(int v) {
	return fDouble == static_cast<double>(v) &&
	this->INHERITED::checkValues(v);
	}
	virtual ~B() {}

	private:
	double fDouble;

	typedef A INHERITED;
	};

	class C : public A {
	public:
	C() {}
	virtual void setValues(int v) {
	fInt64 = static_cast<int64_t>(v);
	this->INHERITED::setValues(v);
	}
	virtual bool checkValues(int v) {
	return fInt64 == static_cast<int64_t>(v) &&
	this->INHERITED::checkValues(v);
	}
	virtual ~C() {}

	private:
	int64_t fInt64;

	typedef A INHERITED;
	};

	// D derives from C and owns a dynamically created B
	class D : public C {
	public:
	D() {
	fB = new B();
	}
	virtual void setValues(int v) {
	fVoidStar = reinterpret_cast<void*>(static_cast<intptr_t>(v));
	this->INHERITED::setValues(v);
	fB->setValues(v);
	}
	virtual bool checkValues(int v) {
	return fVoidStar == reinterpret_cast<void*>(static_cast<intptr_t>(v)) &&
	fB->checkValues(v) &&
	this->INHERITED::checkValues(v);
	}
	virtual ~D() {
	delete fB;
	}
	private:
	void* fVoidStar;
	B* fB;

	typedef C INHERITED;
	};

	class E : public A {
	public:
	E() {}
	virtual void setValues(int v) {
	for (size_t i = 0; i < SK_ARRAY_COUNT(fIntArray); ++i) {
	fIntArray[i] = v;
	}
	this->INHERITED::setValues(v);
	}
	virtual bool checkValues(int v) {
	bool ok = true;
	for (size_t i = 0; ok && i < SK_ARRAY_COUNT(fIntArray); ++i) {
	if (fIntArray[i] != v) {
	ok = false;
	}
	}
	return ok && this->INHERITED::checkValues(v);
	}
	virtual ~E() {}
	private:
	int fIntArray[20];

	typedef A INHERITED;
	};

	A* A::Create(SkRandom* r) {
	switch (r->nextRangeU(0, 4)) {
	case 0:
	return new A;
	case 1:
	return new B;
	case 2:
	return new C;
	case 3:
	return new D;
	case 4:
	return new E;
	default:
	// suppress warning
	return nullptr;
	}
	}

	struct Rec {
	A* fInstance;
	int fValue;
	};

	DEF_TEST(GrMemoryPool, reporter) {
	// prealloc and min alloc sizes for the pool
	static const size_t gSizes[][2] = {
	{0, 0},
	{10 * sizeof(A), 20 * sizeof(A)},
	{100 * sizeof(A), 100 * sizeof(A)},
	{500 * sizeof(A), 500 * sizeof(A)},
	{10000 * sizeof(A), 0},
	{1, 100 * sizeof(A)},
	};
	// different percentages of creation vs deletion
	static const float gCreateFraction[] = {1.f, .95f, 0.75f, .5f};
	// number of create/destroys per test
	static const int kNumIters = 20000;
	// check that all the values stored in A objects are correct after this
	// number of iterations
	static const int kCheckPeriod = 500;

	SkRandom r;
	for (size_t s = 0; s < SK_ARRAY_COUNT(gSizes); ++s) {
	A::SetAllocator(gSizes[s][0], gSizes[s][1]);
	for (size_t c = 0; c < SK_ARRAY_COUNT(gCreateFraction); ++c) {
	SkTDArray<Rec> instanceRecs;
	for (int i = 0; i < kNumIters; ++i) {
	float createOrDestroy = r.nextUScalar1();
	if (createOrDestroy < gCreateFraction[c] \|\|
	0 == instanceRecs.count()) {
	Rec* rec = instanceRecs.append();
	rec->fInstance = A::Create(&r);
	rec->fValue = static_cast<int>(r.nextU());
	rec->fInstance->setValues(rec->fValue);
	} else {
	int d = r.nextRangeU(0, instanceRecs.count() - 1);
	Rec& rec = instanceRecs[d];
	REPORTER_ASSERT(reporter, rec.fInstance->checkValues(rec.fValue));
	delete rec.fInstance;
	instanceRecs.removeShuffle(d);
	}
	if (0 == i % kCheckPeriod) {
	for (int r = 0; r < instanceRecs.count(); ++r) {
	Rec& rec = instanceRecs[r];
	REPORTER_ASSERT(reporter, rec.fInstance->checkValues(rec.fValue));
	}
	}
	}
	for (int i = 0; i < instanceRecs.count(); ++i) {
	Rec& rec = instanceRecs[i];
	REPORTER_ASSERT(reporter, rec.fInstance->checkValues(rec.fValue));
	delete rec.fInstance;
	}
	}
	}
	}

	// GrMemoryPool requires that it's empty at the point of destruction. This helps
	// achieving that by releasing all added memory in the destructor.
	class AutoPoolReleaser {
	public:
	AutoPoolReleaser(GrMemoryPool& pool): fPool(pool) {
	}
	~AutoPoolReleaser() {
	for (void* ptr: fAllocated) {
	fPool.release(ptr);
	}
	}
	void add(void* ptr) {
	fAllocated.push_back(ptr);
	}
	private:
	GrMemoryPool& fPool;
	SkTArray<void*> fAllocated;
	};

	DEF_TEST(GrMemoryPoolAPI, reporter) {
	constexpr size_t kSmallestMinAllocSize = GrMemoryPool::kSmallestMinAllocSize;

	// Allocates memory until pool adds a new block (pool.size() changes).
	auto allocateMemory = [](GrMemoryPool& pool, AutoPoolReleaser& r) {
	size_t origPoolSize = pool.size();
	while (pool.size() == origPoolSize) {
	r.add(pool.allocate(31));
	}
	};

	// Effective prealloc space capacity is >= kSmallestMinAllocSize.
	{
	GrMemoryPool pool(0, 0);
	REPORTER_ASSERT(reporter, pool.preallocSize() == kSmallestMinAllocSize);
	}

	// Effective prealloc space capacity is >= minAllocSize.
	{
	constexpr size_t kMinAllocSize = kSmallestMinAllocSize * 2;
	GrMemoryPool pool(kSmallestMinAllocSize, kMinAllocSize);
	REPORTER_ASSERT(reporter, pool.preallocSize() == kMinAllocSize);
	}

	// Effective block size capacity >= kSmallestMinAllocSize.
	{
	GrMemoryPool pool(kSmallestMinAllocSize, kSmallestMinAllocSize / 2);
	AutoPoolReleaser r(pool);

	allocateMemory(pool, r);
	REPORTER_ASSERT(reporter, pool.size() == kSmallestMinAllocSize);
	}

	// Pool allocates exactly preallocSize on creation.
	{
	constexpr size_t kPreallocSize = kSmallestMinAllocSize * 5;
	GrMemoryPool pool(kPreallocSize, 0);
	REPORTER_ASSERT(reporter, pool.preallocSize() == kPreallocSize);
	}

	// Pool allocates exactly minAllocSize when it expands.
	{
	constexpr size_t kMinAllocSize = kSmallestMinAllocSize * 7;
	GrMemoryPool pool(0, kMinAllocSize);
	AutoPoolReleaser r(pool);

	allocateMemory(pool, r);
	REPORTER_ASSERT(reporter, pool.size() == kMinAllocSize);

	allocateMemory(pool, r);
	REPORTER_ASSERT(reporter, pool.size() == 2 * kMinAllocSize);
	}

	// When asked to allocate amount > minAllocSize, pool allocates larger block
	// to accommodate all internal structures.
	{
	constexpr size_t kMinAllocSize = kSmallestMinAllocSize * 2;
	GrMemoryPool pool(kSmallestMinAllocSize, kMinAllocSize);
	AutoPoolReleaser r(pool);

	REPORTER_ASSERT(reporter, pool.size() == 0);

	constexpr size_t hugeSize = 10 * kMinAllocSize;
	r.add(pool.allocate(hugeSize));
	REPORTER_ASSERT(reporter, pool.size() > hugeSize);

	// Block size allocated to accommodate huge request doesn't include any extra
	// space, so next allocation request allocates a new block.
	size_t hugeBlockSize = pool.size();
	r.add(pool.allocate(0));
	REPORTER_ASSERT(reporter, pool.size() == hugeBlockSize + kMinAllocSize);
	}
	}

	DEF_TEST(GrObjectMemoryPoolAPI, reporter) {
	struct Data {
	int value[5];
	};
	using DataObjectPool = GrObjectMemoryPool<Data>;
	constexpr size_t kSmallestMinAllocCount = DataObjectPool::kSmallestMinAllocCount;

	// Allocates objects until pool adds a new block (pool.size() changes).
	// Returns number of objects that fit into the current block (i.e. before pool.size()
	// changed; newly allocated block always ends up with one object allocated from it).
	auto allocateObjects = [](DataObjectPool& pool, AutoPoolReleaser& r) -> size_t {
	size_t count = 0;
	size_t origPoolSize = pool.size();
	while (pool.size() == origPoolSize) {
	r.add(pool.allocate());
	count++;
	}
	return count - 1;
	};

	// Effective prealloc space capacity is >= kSmallestMinAllocCount.
	{
	DataObjectPool pool(kSmallestMinAllocCount / 3, 0);
	AutoPoolReleaser r(pool);

	size_t preallocCount = allocateObjects(pool, r);
	REPORTER_ASSERT(reporter, preallocCount == kSmallestMinAllocCount);
	}

	// Effective prealloc space capacity is >= minAllocCount.
	{
	DataObjectPool pool(kSmallestMinAllocCount, 2 * kSmallestMinAllocCount);
	AutoPoolReleaser r(pool);

	size_t preallocCount = allocateObjects(pool, r);
	REPORTER_ASSERT(reporter, preallocCount == 2 * kSmallestMinAllocCount);
	}

	// Effective block capacity is >= kSmallestMinAllocCount.
	{
	DataObjectPool pool(kSmallestMinAllocCount, kSmallestMinAllocCount / 2);
	AutoPoolReleaser r(pool);

	// Fill prealloc space
	allocateObjects(pool, r);

	size_t minAllocCount = 1 + allocateObjects(pool, r);
	REPORTER_ASSERT(reporter, minAllocCount == kSmallestMinAllocCount);
	}

	// Pool allocates space for exactly preallocCount objects on creation.
	{
	constexpr size_t kPreallocCount = kSmallestMinAllocCount * 7 / 3;
	DataObjectPool pool(kPreallocCount, 0);
	AutoPoolReleaser r(pool);

	size_t preallocCount = allocateObjects(pool, r);
	REPORTER_ASSERT(reporter, preallocCount == kPreallocCount);
	}

	// Pool allocates space for minAllocCount objects when it adds a new block.
	{
	constexpr size_t kMinAllocCount = kSmallestMinAllocCount * 11 / 3;
	DataObjectPool pool(0, kMinAllocCount);
	AutoPoolReleaser r(pool);

	// Fill prealloc space
	allocateObjects(pool, r);

	size_t firstBlockCount = 1 + allocateObjects(pool, r);
	REPORTER_ASSERT(reporter, firstBlockCount == kMinAllocCount);

	size_t secondBlockCount = 1 + allocateObjects(pool, r);
	REPORTER_ASSERT(reporter, secondBlockCount == kMinAllocCount);
	}
	}

	#endif