GA/GA_DataArrayPageTableImpl.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:
 *      Side Effects Software Inc
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * NAME:        GA_DataArrayPageTableImpl.h (GA Library, C++)
 *
 * COMMENTS:
 */

#ifndef __GA_DATAARRAYPAGETABLEIMPL_H_INCLUDED__
#define __GA_DATAARRAYPAGETABLEIMPL_H_INCLUDED__

#include "GA_Memory.h"
#include "GA_Types.h"

#include <UT/UT_ValArray.h>
#include <UT/UT_Vector3.h>
#include <SYS/SYS_AtomicInt.h>
#include <SYS/SYS_Types.h>

#include <string.h>


/// Internal namespace for GA classes.
/// SUBJECT TO CHANGE! NOT FOR USE BY HDK USERS!
namespace GA_Private {

// class representing a page of numeric data
template <typename T>
class ga_DataArrayPage
{
public:
    ga_DataArrayPage()
        : myRefCount(1)
    {
        myData = (T *)GA_Memory::Malloc(GA_MEM_ATTRIBUTE_DATA,
                                        GA_PAGE_SIZE * sizeof(T));
    }
    ~ga_DataArrayPage()
    {
        GA_Memory::Free(GA_MEM_ATTRIBUTE_DATA, myData,
                        GA_PAGE_SIZE * sizeof(T));
    }

    exint
    getMemoryUsage() const
    {
        return sizeof(*this) + GA_PAGE_SIZE*sizeof(T);
    }

    // thread-safe reference counting methods
    void ref() const            { myRefCount.add(1); }
    void unref()                { if(myRefCount.add(-1) == 0) delete this; }
    bool isShared() const       { return myRefCount.relaxedLoad() != 1; }

    ga_DataArrayPage<T> *
    copy() const
    {
        ga_DataArrayPage<T> *d = new ga_DataArrayPage<T>();
        if (d && d->myData)
            memcpy(d->myData, myData, GA_PAGE_SIZE * sizeof(T));
        return d;
    }

    const T *castToData() const { return myData; }
    T *castToData()             { return myData; }

private:
    mutable SYS_AtomicInt32     myRefCount;
    T *                         myData;
};


template<typename T> static inline bool
ga_IsNotZero(T a)           { return (bool) a; }
template<> inline bool
ga_IsNotZero(UT_Vector3F a) { return a.x() || a.y() || a.z(); }
template<> inline bool
ga_IsNotZero(UT_Vector3D a) { return a.x() || a.y() || a.z(); }


class ga_PageTableBaseImpl
{
};

// Internal implementation extracted from ga_DataArrayPageTable so that
// GA_Detail::getPos3()/setPos3() can perform fast direct lookups.
// @c T is the storage type, either a scalar type or a POD type
// @c TB is the underlying scalar type (same as T if T is a scalar type)
// @c SLICE is the component of a POD type represented by this table
// @c VECTORSIZE is the number of @c TB components making up @c T
template <typename T, typename TB, int SLICE, int VECTORSIZE>
class ga_DataArrayPageTableImpl : public ga_PageTableBaseImpl
{
protected:

    struct ga_DataArrayPagePtr
    {
        union
        {
            ga_DataArrayPage<T> *   ptr;
            char                    rawvalue[sizeof(T)];

            // We can't just have T value because fpreal16 has
            // a constructor.
            const T &   value() const       { return *((T*)rawvalue); }
            T &         value()             { return *((T*)rawvalue); }
            const TB &  scalarValue() const { return ((TB*)rawvalue)[SLICE]; }
        } myData;

        T *             myRawData;

        // Note the usage of this is handled by the caller that thinks
        // this is a pointer.
        exint
        getMemoryUsage() const
        {
            if (!myRawData)
                return 0;
            else
                return myData.ptr->getMemoryUsage();
        }
    };

    mutable UT_ValArray<ga_DataArrayPagePtr>    myPages;

public:

    SYS_FORCE_INLINE TB
    get(GA_Offset offset) const
    {
        return get(GAgetPageNum(offset), GAgetPageOff(offset));
    }
    SYS_FORCE_INLINE void
    set(GA_Offset offset, TB v)
    {
        return set(GAgetPageNum(offset), GAgetPageOff(offset), v);
    }
    SYS_FORCE_INLINE TB
    get(GA_PageNum pageid, GA_PageOff offset) const
    {
        const ga_DataArrayPagePtr &page = myPages(pageid);
        if (!page.myRawData)
            return page.myData.scalarValue();
        else
            return ((TB*)&(page.myRawData[offset]))[SLICE];
    }
    SYS_FORCE_INLINE void
    set(GA_PageNum pageid, GA_PageOff offset, TB v)
    {
        const ga_DataArrayPagePtr &page = myPages(pageid);
        if (page.myRawData)
        {
            if (page.myData.ptr->isShared())
            {
                ((TB*)&forceHardenToData(pageid)[offset])[SLICE] = v;
            }
            else
                ((TB*)&page.myRawData[offset])[SLICE] = v;
        }
        else
        {
            // Setting a constant page.
            if (page.myData.scalarValue() != v)
            {
                // Need to actually expand.
                ((TB*)&forceHardenToData(pageid)[offset])[SLICE] = v;
            }
        }
    }

    SYS_FORCE_INLINE void
    add(GA_PageNum pageid, GA_PageOff offset, TB v)
    {
        ((TB*)&hardenToData(pageid)[offset])[SLICE] += v;
    }

    SYS_FORCE_INLINE T
    getVector(GA_Offset offset) const
    {
        return getVector(GAgetPageNum(offset), GAgetPageOff(offset));
    }
    SYS_FORCE_INLINE void
    setVector(GA_Offset offset, T v)
    {
        return setVector(GAgetPageNum(offset), GAgetPageOff(offset), v);
    }
    SYS_FORCE_INLINE T
    getVector(GA_PageNum pageid, GA_PageOff offset) const
    {
        const ga_DataArrayPagePtr &page = myPages(pageid);
        if (!page.myRawData)
            return page.myData.value();
        else
            return page.myRawData[offset];
    }
    SYS_FORCE_INLINE void
    setVector(GA_PageNum pageid, GA_PageOff offset, T v)
    {
        const ga_DataArrayPagePtr &page = myPages(pageid);
        if (page.myRawData)
        {
            if (page.myData.ptr->isShared())
            {
                forceHardenToData(pageid)[offset] = v;
            }
            else
                page.myRawData[offset] = v;
        }
        else
        {
            // Setting a constant page.
            if (page.myData.value() != v)
            {
                // Need to actually expand.
                forceHardenToData(pageid)[offset] = v;
            }
        }
    }
    SYS_FORCE_INLINE void
    addVector(GA_PageNum pageid, GA_PageOff offset, T v)
    {
        hardenToData(pageid)[offset] += v;
    }

    ga_DataArrayPage<T> *
    createConstantPage(T value) const
    {
        ga_DataArrayPage<T> *   page = new ga_DataArrayPage<T>();
        T *                     data = page->castToData();

        if (ga_IsNotZero(value))
        {
            for (GA_Size i = 0; i < GA_PAGE_SIZE; ++i)
                data[i] = value;
        }
        else
        {
            memset(data, 0, GA_PAGE_SIZE * sizeof(T));
        }

        return page;
    }

    // Doesn't test, just hardens.
    T *
    forceHardenToData(GA_Size i)
    {
        ga_DataArrayPagePtr &   page = myPages(i);
        ga_DataArrayPage<T> *   pageptr;
        T *                     result;

        if (!page.myRawData)
        {
            pageptr = createConstantPage(page.myData.value());
            page.myData.ptr = pageptr;
            page.myRawData = result = pageptr->castToData();
        }
        else
        {
            pageptr = page.myData.ptr;
            ga_DataArrayPage<T> *oldpage = pageptr;
            pageptr = oldpage->copy();
            page.myData.ptr = pageptr;
            page.myRawData = result = pageptr->castToData();
            oldpage->unref();
        }
        return result;
    }

    SYS_FORCE_INLINE T *
    hardenToData(GA_Size pageid)
    {
        const ga_DataArrayPagePtr &page = myPages(pageid);

        if (!page.myRawData)
        {
            return forceHardenToData(pageid);
        }
        else
        {
            // Setting a constant page.
            if (page.myData.ptr->isShared())
            {
                return forceHardenToData(pageid);
            }
            return page.myRawData;
        }
    }

    // Does not unshare shared pages.
    SYS_FORCE_INLINE T *
    softenToData(GA_Size pageid)
    {
        const ga_DataArrayPagePtr &page = myPages(pageid);

        if (!page.myRawData)
        {
            return forceHardenToData(pageid);
        }
        else
        {
            return page.myRawData;
        }
    }

};

// Convenience types
typedef ga_DataArrayPageTableImpl<UT_Vector3F,fpreal32,0,3>
            ga_DataArrayPageTableImplV3;
typedef ga_DataArrayPageTableImpl<int16,int16,0,1>
            ga_DataArrayPageTableImplI16;
typedef ga_DataArrayPageTableImpl<int32,int32,0,1>
            ga_DataArrayPageTableImplI32;
typedef ga_DataArrayPageTableImpl<int64,int64,0,1>
            ga_DataArrayPageTableImplI64;

} // namespace GA_Private
#endif // __GA_DATAARRAYPAGETABLEIMPL_H_INCLUDED__

---