GrMemoryPoolBench.cpp File Reference

#include "bench/Benchmark.h"
#include "src/base/SkRandom.h"
#include "src/gpu/ganesh/GrMemoryPool.h"
#include <type_traits>

Go to the source code of this file.

Classes
class	GrMemoryPoolBench

Functions
template<typename T >
static void	run_stack (GrMemoryPool *pool, int loops)
template<typename T >
static void	run_queue (GrMemoryPool *pool, int loops)
template<typename T >
static void	run_pushpop (GrMemoryPool *pool, int loops)
template<typename T >
static void	run_random (GrMemoryPool *pool, int loops)

Variables
static const int	kLargePool = 10 * (1 << 10)
static const int	kSmallPool = GrMemoryPool::kMinAllocationSize

Function Documentation

run_pushpop()

template<typename T >

static void run_pushpop ( GrMemoryPool *  pool, int  loops  )

static

Definition at line 91 of file GrMemoryPoolBench.cpp.

                                                       {
    static const int kMaxObjects = 4 * (1 << 10);
    T* objs[kMaxObjects];
    for (int i = 0; i < loops; ++i) {
        // Push N objects into the pool (or heap if pool is null)
        for (int j = 0; j < kMaxObjects; ++j) {
            if (pool) {
                objs[j] = (T*) pool->allocate(sizeof(T));
                pool->release(objs[j]);
            } else {
                objs[j] = new T;
                delete objs[j];
            }
        }
 
        // Everything has been cleaned up for the next loop
    }
}

run_queue()

template<typename T >

static void run_queue ( GrMemoryPool *  pool, int  loops  )

static

Definition at line 67 of file GrMemoryPoolBench.cpp.

                                                     {
    static const int kMaxObjects = 4 * (1 << 10);
    T* objs[kMaxObjects];
    for (int i = 0; i < loops; ++i) {
        // Push N objects into the pool (or heap if pool is null)
        for (int j = 0; j < kMaxObjects; ++j) {
            objs[j] = pool ? (T*) pool->allocate(sizeof(T)) : new T;
        }
        // Pop N objects off in FIFO order
        for (int j = 0; j < kMaxObjects; ++j) {
            if (pool) {
                pool->release(objs[j]);
            } else {
                delete objs[j];
            }
        }
 
        // Everything has been cleaned up for the next loop
    }
}

run_random()

template<typename T >

static void run_random ( GrMemoryPool *  pool, int  loops  )

static

Definition at line 112 of file GrMemoryPoolBench.cpp.

                                                      {
    static const int kMaxObjects = 4 * (1 << 10);
    T* objs[kMaxObjects];
    for (int i = 0; i < kMaxObjects; ++i) {
        objs[i] = nullptr;
    }
 
    auto del = [&](int j) {
        // Delete
        if (pool) {
            pool->release(objs[j]);
        } else {
            delete objs[j];
        }
        objs[j] = nullptr;
    };
 
    SkRandom r;
    for (int i = 0; i < loops; ++i) {
        // Execute 2*kMaxObjects operations, which should average to N create and N destroy,
        // followed by a small number of remaining deletions.
        for (int j = 0; j < 2 * kMaxObjects; ++j) {
            int k = r.nextRangeU(0, kMaxObjects-1);
            if (objs[k]) {
                del(k);
            } else {
                // Create
                objs[k] = pool ? (T*) pool->allocate(sizeof(T)) : new T;
            }
        }
 
        // Ensure everything is null for the next loop
        for (int j = 0; j < kMaxObjects; ++j) {
            if (objs[j]) {
                del(j);
            }
        }
    }
}

run_stack()

template<typename T >

static void run_stack ( GrMemoryPool *  pool, int  loops  )

static

Definition at line 43 of file GrMemoryPoolBench.cpp.

                                                     {
    static const int kMaxObjects = 4 * (1 << 10);
    T* objs[kMaxObjects];
    for (int i = 0; i < loops; ++i) {
        // Push N objects into the pool (or heap if pool is null)
        for (int j = 0; j < kMaxObjects; ++j) {
            objs[j] = pool ? (T*) pool->allocate(sizeof(T)) : new T;
        }
        // Pop N objects off in LIFO order
        for (int j = kMaxObjects - 1; j >= 0; --j) {
            if (pool) {
                pool->release(objs[j]);
            } else {
                delete objs[j];
            }
        }
 
        // Everything has been cleaned up for the next loop
    }
}

Variable Documentation

kLargePool

const int kLargePool = 10 * (1 << 10)

static

Definition at line 189 of file GrMemoryPoolBench.cpp.

kSmallPool

const int kSmallPool = GrMemoryPool::kMinAllocationSize

static

Definition at line 190 of file GrMemoryPoolBench.cpp.