GAS_OpenCL.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:        GAS_OpenCL.h ( GAS Library, C++)
 *
 * COMMENTS:
 */

#ifndef __GAS_OpenCL_h__
#define __GAS_OpenCL_h__

#include "GAS_SubSolver.h"
#include "GAS_Utils.h"
#include <GA/GA_SplittableRange.h>
#include <CE/CE_Context.h>
#include <CE/CE_Snippet.h>
#include <SIM/SIM_Query.h>
#include <SIM/SIM_QueryCombine.h>
#include "GAS_OpenCLParms.proto.h"

class GA_CEAttribute;

class GAS_API GAS_OpenCL : public GAS_SubSolver
{
public:
    // The live parameters we are solving with
    // These are transitory for the solve.
    const GAS_OpenCLParms       &param() const { return myAtParms; }

    // The parameters we set from tne node, representing our original
    // parameters (before @ binding)
    GAS_OpenCLParms             &nodeParam() { return myNodeParms; }
    const GAS_OpenCLParms       &nodeParam() const { return myNodeParms; }

    OP_VERSION                   versionParms() const { return myVersion; }
    void                         setVersionParms(OP_VERSION version) { myVersion = version; }

    // Static display callback
    static int displayKernel(void * data, int, fpreal t, const PRM_Template*);
    static int expandKernel(void * data, int, fpreal t, const PRM_Template*);

    // Populate a GAS_OpenCLParms from an OP_Node using our default
    // names
    static void loadParmsFromOp(GAS_OpenCLParms &parms, const OP_Node *node, fpreal t);

protected:
    explicit   GAS_OpenCL(const SIM_DataFactory *factory);
     ~GAS_OpenCL() override;

    /// Creates a SIM_QueryArrays object to treat impact as a record
    SIM_Query           *createQueryObjectSubclass() const override
    {
        return new SIM_QueryCombine(BaseClass::createQueryObjectSubclass(), nodeParam().createQueryObject(this));
    }
    void         makeEqualSubclass(const SIM_Data *source) override
    {
        BaseClass::makeEqualSubclass(source);
        const GAS_OpenCL *src = SIM_DATA_CASTCONST(source, GAS_OpenCL);
        if (src)
        {
            nodeParam() = src->nodeParam();
            setVersionParms(src->versionParms());
        }
    }
    void                 saveSubclass(std::ostream &os) const override
    {
        BaseClass::saveSubclass(os);
        myNodeParms.save(os);
    } 
    bool                 loadSubclass(UT_IStream &is) override
    {
        if (!BaseClass::loadSubclass(is))
            return false;
        if (!myNodeParms.load(is))
            return false;
        return true;
    }
    /// The overloaded callback that GAS_SubSolver will invoke to
    /// perform our actual computation.  We are giving a single object
    /// at a time to work on.
    bool          solveGasSubclass(SIM_Engine &engine,
                                   SIM_Object *obj,
                                   SIM_Time time,
                                   SIM_Time timestep) override;


private:
    GAS_OpenCLParms             myNodeParms;
    GAS_OpenCLParms             myAtParms;
    OP_VERSION                  myVersion;

    /// We define this to be a DOP_Auto node which means we do not
    /// need to implement a DOP_Node derivative for this data.  Instead,
    /// this description is used to define the interface.
    static const SIM_DopDescription *getDopDescription();


    // forces alignment of CE_Grids
    void forceAlign( CE_Grid *&ret, SIM_RawField *src, const SIM_RawField *ex );


    bool setAndExecuteKernel(cl::Kernel  &kernel, 
                             CE_Snippet::RunOver runover,
                             const UT_Array<UT_Array< CE_Grid *> > &fields,
                             cl::NDRange global, 
                             cl::NDRange local,
                             exint numtiles,
                             cl::Buffer tilestarts,
                             SIM_Object  *obj,
                             fpreal time,
                             int frame,
                             fpreal timestep);

    bool setAndExecuteKernel(cl::Kernel  &kernel, 
                             cl::Kernel &singlekernel,
                             int singlekernelmaxitems,
                             CE_Snippet::RunOver runover,
                             const UT_Array<UT_Array< CE_Grid *> > &fields,
                             const UT_Array<cl::NDRange> &offsets,
                             const UT_Int32Array &sizes,
                             const UT_Int32Array &singleitems,
                             const UT_Array<cl::NDRange> &globals,
                             const UT_Array<cl::NDRange> &locals,
                             exint numtiles,
                             cl::Buffer tilestarts,
                             SIM_Object  *obj,
                             fpreal time,
                             int frame,
                             fpreal timestep);

    bool setKernelArguments(cl::Kernel &kernel, int paramcount,
                            CE_Snippet::RunOver runover,
                            const UT_Array<UT_Array< CE_Grid *> > &grids,
                            SIM_Object * obj,
                            UT_ErrorManager *errors,
                            UT_Array<cl::Buffer> &owned_buffers,
                            UT_Array<cl::Buffer> &referenced_buffers,
                            fpreal time, int frame, fpreal timestep,
                            int singleworkitems = 0);

    void createOptionalAttributeOptions( CE_Snippet::RunOver runover, SIM_Object *obj, UT_WorkBuffer &options );

    // Returns the number of items that can be run int single workgroup
    // mode, zero if not possible.
    int maxSingleWorkgroupItems( SIM_Object *obj, cl::Kernel &kernel);

    // Main Kernel Execution versions

    bool executeOpenCLKernel(cl::Kernel &kernel, 
                             cl::Kernel &singlekernel,
                             int singlekernelmaxitems,
                             CE_Snippet::RunOver runover,
                             SIM_Object * obj,
                             fpreal time, int frame, fpreal timestep);

    // Kernel Execution versions
    bool executeOpenCLKernelUnaligned(cl::Kernel &kernel, SIM_Object * obj, fpreal time,
                                      int frame, fpreal timestep);
    bool executeOpenCLKernelAligned(  cl::Kernel &kernel, SIM_Object * obj, fpreal time,
                                      int frame, fpreal timestep);
    bool executeOpenCLKernelAlignedSingleAlign( cl::Kernel &kernel,
                                                SIM_Object * obj, fpreal time, int frame, fpreal timestep);
    bool executeOpenCLKernelAlignedMultiAlign(  cl::Kernel &kernel,
                                                SIM_Object * obj, fpreal time, int frame, fpreal timestep);
    bool executeOpenCLKernelGeometry(cl::Kernel &kernel, 
                                     cl::Kernel &singlekernel, 
                                     int singlekernelmaxitems,
                                     CE_Snippet::RunOver runover,
                                     SIM_Object * obj, 
                                     fpreal time, int frame, fpreal timestep);
    bool executeOpenCLKernelVDB(cl::Kernel &kernel, 
                                 CE_Snippet::RunOver runover,
                                 SIM_Object * obj, 
                                 fpreal time, int frame, fpreal timestep);

    /// These macros are necessary to bind our node to the factory and
    /// ensure useful constants like BaseClass are defined.
    DECLARE_STANDARD_GETCASTTOTYPE();
    DECLARE_DATAFACTORY(GAS_OpenCL,
                        GAS_SubSolver,
                        "Gas OpenCL",
                        getDopDescription());
};

#endif