UT/UT_SmallObject.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Mark Elendt
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        UT_SmallObject.h ( UT Library, C++)
 *
 * COMMENTS:    Small object allocator.
 */

#ifndef __UT_SmallObject__
#define __UT_SmallObject__

#include "UT_SmallObjectAllocator.h"


// A small object allocator:
//      cleanPages:
//         Pages are freed when they become empty. Requires an extra 4 bytes
//         per object and can hurt performance. But reduces memory footprint.
//      pageSize:
//         Number of objects per page (how many objects are allocated at once).
//      maxObjectSize:
//         The size above which we revert to regular new and delete.
//      threadSafe:
//         Will ensure that allocs/free's are done in a thread safe manner.
//      SuperClass:
//         Allows you to create a UT_SmallObject with an arbitrary base class.
//         This is useful if you want to have class A, with some subclass B
//         which is a small object, but another subclass C which is not. In
//         This case you would have:
//              class B : public UT_SmallObject<... , A> { };
//              class C : public A { };
//      SubClass:
//         Set this to the class being created. The only reason for this
//         parameter is so that we won't get linker errors on Windows.
#define UT_SMALLOBJECT_CLEANPAGES_DEFAULT       true
#define UT_SMALLOBJECT_CLEANPAGES_ON            true
#define UT_SMALLOBJECT_CLEANPAGES_OFF           false

#define UT_SMALLOBJECT_PAGESIZE_DEFAULT         1024

#define UT_SMALLOBJECT_THREADSAFE_DEFAULT       true
#define UT_SMALLOBJECT_THREADSAFE_ON            true
#define UT_SMALLOBJECT_THREADSAFE_OFF           false

#define UT_SMALLOBJECT_MAXOBJECTSIZE_DEFAULT    128

// We need a default SuperClass argument. Any empty class with a virtual
// destructor will do the trick.
class UT_SmallObjectDefaultSuperClass
{
public:
};

// The UT_SmallObject class template.
template <class SubClass,
          bool cleanPages = UT_SMALLOBJECT_CLEANPAGES_DEFAULT,
          int pageSize = UT_SMALLOBJECT_PAGESIZE_DEFAULT,
          bool threadSafe = UT_SMALLOBJECT_THREADSAFE_DEFAULT,
          size_t maxObjectSize = UT_SMALLOBJECT_MAXOBJECTSIZE_DEFAULT,
          class SuperClass = UT_SmallObjectDefaultSuperClass>
class UT_SmallObject : public SuperClass
{
public:
    static void *operator new(size_t size)
                 {
                     return UT_MySmallObjectAllocator::
                            getAllocator()->allocate(size);
                 }
    static void *operator new(size_t /*size*/, void *p)
                 {
                     return p;
                 }
    static void  operator delete(void *p, size_t size)
                 {
                     UT_MySmallObjectAllocator::
                            getAllocator()->deallocate(p, size);
                 }

private:
    class UT_MySmallObjectAllocator : public UT_SmallObjectAllocator
    {
        public:
            UT_MySmallObjectAllocator()
                : UT_SmallObjectAllocator(cleanPages, pageSize,
                                          maxObjectSize, threadSafe)
            { }

            static UT_MySmallObjectAllocator *getAllocator()
            {
                static UT_MySmallObjectAllocator        *theAllocator = 0;

                if( !theAllocator )
                    theAllocator = new UT_MySmallObjectAllocator();

                return theAllocator;
            }
    };
};


#endif

---