path: root/tests/GrMemoryPoolTest.cpp

/*
 * 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