GA_CEAttribute.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.
 *
 * NAME:        GA_CEAttribute.h ( GA Library, C++)
 *
 * COMMENTS:
 *      A GA_Attribute backed on the Compute Engine
 */

#ifndef __GA_CEAttribute__
#define __GA_CEAttribute__

#include "GA_API.h"

#include <CE/CE_Context.h>
#include "GA_Detail.h"
#include "GA_Attribute.h"

class GA_API GA_CEAttribute
{
public:
    GA_CEAttribute();

    GA_CEAttribute(GA_Size entries, GA_StorageClass storage, GA_Precision precision,
                   GA_Size tuplesize, bool isarray,
                   cl::Buffer buffer, cl::Buffer indexbuffer,
                   bool leave_on_gpu = false);

    virtual ~GA_CEAttribute();

    void                clearBuffers();

    bool                isValid() const
    {
        return myBuffer();
    }

    int64               getDeviceMemoryUsage() const;

    cl::Buffer          buffer() const { return myBuffer; }
    cl::Buffer          indexBuffer() const { return myIndexBuffer; }
    GA_Size             entries() const { return myEntries; }
    int                 tupleSize() const { return myTupleSize; }
    GA_StorageClass     storage() const { return myStorage; }
    GA_Precision        precision() const { return myPrecision; }
    bool                isArray() const { return myIsArray; }

    bool                attributeToOCL(const GA_Detail *gdp,
                                    GA_AttributeOwner owner,
                                    const char *aname,
                                    GA_StorageClass storage,
                                    int &tuplesize,
                                    bool isarray,
                                    bool docopy = true)
    {
        return attributeToOCL(gdp, owner, aname, storage, GA_PRECISION_32,
                              tuplesize, isarray, docopy);
    }
    bool                attributeToOCL(const GA_Detail *gdp,
                                    GA_AttributeOwner owner,
                                    const char *aname,
                                    GA_StorageClass storage,
                                    GA_Precision precision,
                                    int &tuplesize,
                                    bool isarray,
                                    bool docopy = true)
    {
        if (!gdp) return false;
        if (!UTisstring(aname))
            return false;
        const GA_Attribute *attrib = gdp->getAttributes().findAttribute(owner, aname);
        if (!attrib)
            return false;
        return attributeToOCL(attrib, storage, precision, tuplesize, isarray, docopy);
    }
    bool                attributeToOCL(const GA_Attribute *attrib,
                                    GA_StorageClass storage,
                                    GA_Precision precision,
                                    int &tuplesize,
                                    bool isarray,
                                    bool docopy = true);

    bool                intToOCL(const UT_Array<int64> &data,
                                   GA_StorageClass storage,
                                   GA_Precision precision,
                                   bool docopy = true);

    bool                intArrayToOCL(const UT_Array<UT_Array<int64>> &data,
                                   GA_StorageClass storage,
                                   GA_Precision precision,
                                   bool docopy = true);

    bool                packedIntArrayToOCL(
                                   const UT_PackedArrayOfArrays<int64> &data,
                                   GA_StorageClass storage,
                                   GA_Precision precision,
                                   bool docopy = true);

    bool                oclToAttribute(GA_Detail *gdp, GA_AttributeOwner owner, const char *aname)
    {
        if (!gdp) return false;
        if (!UTisstring(aname))
            return false;
        GA_Attribute *attrib = gdp->getAttributes().findAttribute(owner, aname);
        if (!attrib)
            return false;
        return oclToAttribute(attrib);
    }
    bool                oclToAttribute(GA_Attribute *attrib);

    bool                isWriteBackRequired() const { return myWriteBackRequired; }
    void                setWriteBackRequired(bool isrequired) { myWriteBackRequired = isrequired; }

protected:

    // GPU Buffers:
    cl::Buffer          myBuffer;
    cl::Buffer          myIndexBuffer;

    // CPU Buffers:
    UT_Array<cl_int>    myIndexArray;
    // It would be much more proper to use cl_half here, but that
    // is not a computable type so it is easy to accidentally cast
    // fprealy16 to short silently.  Instead we rely on bit equivalency.
    UT_Array<fpreal16>  myFloat16Array;
    UT_Array<cl_float>  myFloat32Array;
    UT_Array<cl_double> myFloat64Array;
    UT_Array<cl_short>  myInt16Array;
    UT_Array<cl_int>    myInt32Array;
    UT_Array<cl_long>   myInt64Array;

    // Number of entries.
    GA_Size             myEntries;
    GA_Size             myTupleSize;
    GA_StorageClass     myStorage;
    GA_Precision        myPrecision;
    bool                myIsArray;

    // Whether the buffer has been written to by CE
    bool                myWriteBackRequired;
};

#endif