CE_SnippetKernelBind.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: CE_SnippetImpl.h ( CE Library, C++)
 *
 * COMMENTS: Implementation of snippet manipulation for OpenCL
 */

#ifndef __CE_SnippetKernelBind__
#define __CE_SnippetKernelBind__

#include "CE_API.h"
#include "CE_Context.h"
#include "CE_Snippet.h"
#include <UT/UT_WorkBuffer.h>
#include <UT/UT_ErrorManager.h>

namespace CE_Snippet
{
    template <CE_Precision PREC, typename OP>
    bool setKernelArgument(const Binding &binding, int p,
            cl::Kernel &kernel, int &argidx,
            UT_Array<cl::Buffer> &buffers,
            fpreal timestep,
            UT_ErrorManager *error,
            UT_ErrorSeverity missingseverity,
            const OP &op);

    /// Binds each of the bindings in turn.
    /// OP is a callback structure that knows how to bind the various
    /// bespoke types, with
    /// bool operator()(const CE_Snippet::Binding &binding, int p,
    ///                        cl::Kernel &kernel, int &argidx,
    ///                        UT_ErrorManager *error,
    ///                        CE_Precision PREC)
    template <typename OP>
    inline bool setKernelArguments(const UT_Array<Binding> &bindings,
            BindingPrecision nodeprecision,
            cl::Kernel &kernel, int &argidx,
            UT_Array<cl::Buffer> &buffers,
            fpreal timestep,
            UT_ErrorManager *error,
            UT_ErrorSeverity missingseverity,
            const OP &op)
    {
        bool            ok = true;
        int             p = 0;
        for (auto && binding : bindings)
        {
            auto precision = binding.precision;
            if (precision == BindingPrecision::NODE)
                precision = nodeprecision;
            switch (precision)
            {
                case BindingPrecision::NODE:
                    UT_ASSERT(!"This should have been handled");
                    break;
                case BindingPrecision::_16:
                    ok &= setKernelArgument<CE_16, OP>(binding, p, kernel, argidx, buffers, timestep, error, missingseverity, op);
                    break;
                case BindingPrecision::_32:
                    ok &= setKernelArgument<CE_32, OP>(binding, p, kernel, argidx, buffers, timestep, error, missingseverity, op);
                    break;
                case BindingPrecision::_64:
                    ok &= setKernelArgument<CE_64, OP>(binding, p, kernel, argidx, buffers, timestep, error, missingseverity, op);
                    break;

            }
            if (!ok)
                break;
            p++;
        }
        return ok;
    }

    /// Adds an error to the error manager for mis-binding an argument.
    CE_API void reportSetArgError(const char *name, int argidx, 
                    int pidx, const char *type,
                    const char *extra, UT_ErrorManager *error);

    template <typename TYPE>
    inline void bindKernelArgRaw(TYPE *val, int tuplesize,
                  cl::Kernel &kernel, int &argidx,
                  const char *name, const char *type, int pidx, 
                  UT_ErrorManager *error,
                  const char *extra = 0)
    {
        try
        {
            kernel.setArg( argidx, tuplesize * sizeof(TYPE), val);
            argidx++;
        }
        catch (cl::Error &)
        {
            reportSetArgError(name, argidx, pidx, type, extra, error);
            throw;
        }
    }
    /// Binds a kernel argument of the type, incrementing the argidx
    /// Will throw an error and add the error to the provided error manager.
    ///{
    inline void bindKernelArgI(cl_int val, cl::Kernel &kernel, int &argidx,
                  const char *name, int pidx, UT_ErrorManager *error,
                  const char *extra = 0)
    { bindKernelArgRaw(&val, 1, kernel, argidx, name, "int", pidx, error, extra); }
    inline void bindKernelArgI2(cl_int *val, cl::Kernel &kernel, int &argidx,
                  const char *name, int pidx, UT_ErrorManager *error,
                  const char *extra = 0)
    { bindKernelArgRaw(val, 2, kernel, argidx, name, "int2", pidx, error, extra); }
    inline void bindKernelArgF(cl_float val, cl::Kernel &kernel, int &argidx,
                  const char *name, int pidx, UT_ErrorManager *error,
                  const char *extra = 0)
    { bindKernelArgRaw(&val, 1, kernel, argidx, name, "float", pidx, error, extra); }
    /// NOTE: This binds float4 due to vagaries of cl!
    inline void bindKernelArgV3(cl_float *val, cl::Kernel &kernel, int &argidx,
                  const char *name, int pidx, UT_ErrorManager *error,
                  const char *extra = 0)
    { bindKernelArgRaw(val, 4, kernel, argidx, name, "float3", pidx, error, extra); }
    inline void bindKernelArgV4(cl_float *val, cl::Kernel &kernel, int &argidx,
                  const char *name, int pidx, UT_ErrorManager *error,
                  const char *extra = 0)
    { bindKernelArgRaw(val, 4, kernel, argidx, name, "float4", pidx, error, extra); }
    inline void bindKernelArgV16(cl_float *val, cl::Kernel &kernel, int &argidx,
                  const char *name, int pidx, UT_ErrorManager *error,
                  const char *extra = 0)
    { bindKernelArgRaw(val, 16, kernel, argidx, name, "float16", pidx, error, extra); }
    inline void bindKernelArgB(cl::Buffer val, cl::Kernel &kernel, int &argidx,
                  const char *name, int pidx, const char *type,
                  UT_ErrorManager *error,
                  const char *extra = 0)
    {
        try
        {
            kernel.setArg( argidx, val);
            argidx++;
        }
        catch (cl::Error &)
        {
            reportSetArgError(name, argidx, pidx, type, extra, error);
            throw;
        }
    }

    ///}
    template <CE_Precision PREC, typename OP>
    inline bool 
    setKernelArgument(const CE_Snippet::Binding &binding,
            int p,
            cl::Kernel &kernel, int &argidx,
            UT_Array<cl::Buffer> &buffers,
            fpreal timestep,
            UT_ErrorManager *error,
            UT_ErrorSeverity missingseverity,
            const OP &op)
    {
        bool    ok      = true;
        UT_String       retrieveStr;

        BindingType     paramtype = BindingType::INVALID;
        CEfloatH<PREC>  param_float     = 0;
        CE_Context  *clcontext  = CE_Context::getContext();
        CEintH<PREC>    param_int;
        UT_Vector4D     param_float4;
        UT_Vector3D     param_float3;
        UT_Vector2D     param_float2;
        UT_String       param_string;

        CEfloatH<PREC>  param_fpreal_array[16];

        paramtype = binding.type;

        // set base parameter values
        switch (paramtype)
        {
            // Single integer
            case BindingType::INT:
                param_int = binding.intval;
                CE_Snippet::bindKernelArgRaw(&param_int, 1, 
                        kernel, argidx, binding.name, "int", p, error);
                break;

            // Single Float
            case BindingType::FLOAT:
            {
                BindingTimescale                timemethod;
                param_float   = binding.fval;
                timemethod = binding.timescale;

                switch( timemethod )
                {
                    case BindingTimescale::NONE: // None
                        break; 
                    case BindingTimescale::MULT: // * Timescale
                        param_float *= timestep;
                        break; 
                    case BindingTimescale::INVERT: // 1 / Timescale
                        param_float /= timestep;
                        break;
                    case BindingTimescale::POW: // e ^ timestep
                        param_float = SYSexp( param_float * timestep );
                        break;
                    default:
                        break;
                }

                CE_Snippet::bindKernelArgRaw(&param_float, 1, 
                        kernel, argidx, binding.name, "float", p, error);
                break;
            }

            // Float Vector 2
            case BindingType::FLOAT2:
                param_float2  = binding.v2val;
                param_fpreal_array[0] = param_float2(0);
                param_fpreal_array[1] = param_float2(1);

                CE_Snippet::bindKernelArgRaw(param_fpreal_array, 2,
                        kernel, argidx, binding.name, "float2", p, error);
                break;

            // Float Vector 3
            case BindingType::FLOAT3:
                param_float3  = binding.v3val;
                param_fpreal_array[0] = param_float3(0);
                param_fpreal_array[1] = param_float3(1);
                param_fpreal_array[2] = param_float3(2);
                param_fpreal_array[3] = 0;

                CE_Snippet::bindKernelArgRaw(param_fpreal_array, 4,
                        kernel, argidx, binding.name, "float3", p, error);
                break;

            // Float Vector 4
            case BindingType::FLOAT4:
                param_float4  = binding.v4val;
                param_fpreal_array[0] = param_float4(0);
                param_fpreal_array[1] = param_float4(1);
                param_fpreal_array[2] = param_float4(2);
                param_fpreal_array[3] = param_float4(3);
                CE_Snippet::bindKernelArgRaw(param_fpreal_array, 4,
                        kernel, argidx, binding.name, "float4", p, error);
                break;

            // Float vector 8
            case BindingType::FLOAT8:
                param_float4  = binding.v4val;
                param_fpreal_array[0] = param_float4(0);
                param_fpreal_array[1] = param_float4(1);
                param_fpreal_array[2] = param_float4(2);
                param_fpreal_array[3] = param_float4(3);
                param_float4  = binding.v4bval;
                param_fpreal_array[4+0] = param_float4(0);
                param_fpreal_array[4+1] = param_float4(1);
                param_fpreal_array[4+2] = param_float4(2);
                param_fpreal_array[4+3] = param_float4(3);
                CE_Snippet::bindKernelArgRaw(param_fpreal_array, 8,
                        kernel, argidx, binding.name, "float8", p, error);
                break;

            // Float vector 16
            case BindingType::FLOAT16:
            {
                for (int r = 0; r < 4; r++)
                    for (int c = 0; c < 4; c++)
                        param_fpreal_array[r*4+c] = binding.m4val(r, c);
                CE_Snippet::bindKernelArgRaw(param_fpreal_array, 16,
                        kernel, argidx, binding.name, "float8", p, error);
                break;
            }

            case BindingType::RAMP:
            {
                const cl_int ramp_size = binding.rampsize;
                const int tuplesize = binding.ramptype == BindingRampType::VECTOR ? 3 : 1;

                // load the ramp, allocate the required buffer, and populate with
                // ramp data

                UT_Array<CEfloatH<PREC>> ramp_array;
                ramp_array.entries(ramp_size * tuplesize);

                if (binding.ramp)
                {
                    int writepos = 0;
                    for (int i = 0; i < ramp_size; i++)
                    {
                        float values[4];
                        fpreal pos = i / fpreal(ramp_size - 1);
                        binding.ramp->rampLookup( pos, values );
                        for (int j = 0; j < tuplesize; j++)
                            ramp_array(writepos++) = values[j]; 
                    }
                }
                else if (binding.rampdata)
                {
                    for (int i = 0; i < ramp_array.entries(); i++)
                        ramp_array[i] = binding.rampdata[i];
                    // This array is strictly a temporary value used to perform the binding.
                    // Clear it so we don't leave a dangling pointer.
                    binding.rampdata = nullptr;
                }
                else
                {
                    ramp_array.constant(0);
                }

                const size_t ramp_data_size = ramp_size * tuplesize * sizeof( CEfloatH<PREC> );
                cl::Buffer ramp_buffer = clcontext->allocBuffer(ramp_data_size);
                // Blocking since we will free our array shortly.
                clcontext->writeBuffer( ramp_buffer, ramp_data_size, ramp_array.array() );
                buffers.append(ramp_buffer);

                CE_Snippet::bindKernelArgI(ramp_size, kernel, argidx, binding.name, p, error, "size");
                CE_Snippet::bindKernelArgB(ramp_buffer, kernel, argidx, binding.name, p, "float *", error, "data");
                break;
            }

            case BindingType::FIELD_S:
            case BindingType::FIELD_V:
            case BindingType::FIELD_M:
            {
                // Ignore unbound optional volumes
                if (!op(binding, p, kernel, argidx, error, PREC))
                {
                    UT_WorkBuffer msg;
                    msg.sprintf("Invalid field '%s'", (const char *) binding.fieldname);
                    if (missingseverity != UT_ERROR_NONE)
                        error->addGeneric("Common", UT_ERROR_JUST_STRING, msg.buffer(), missingseverity);
                    return false;
                }

                break;
            }
            case BindingType::ATTRIBUTE:
            {
                // Fetch our geometry
                BindingAttribType atype = binding.attribtype;
                int tuplesize = binding.attribsize;
                bool isarray = atype == BindingAttribType::FLOATARRAY || atype == BindingAttribType::INTARRAY;
                bool optional = binding.optional;

                if (!op(binding, p, kernel, argidx, error, PREC))
                {
                    if (!optional)
                    {
                        UT_WorkBuffer msg;
                        msg.sprintf("Invalid attribute '%s'", (const char *) binding.attribute);
                        if (missingseverity != UT_ERROR_NONE)
                            error->addGeneric("Common", UT_ERROR_JUST_STRING, msg.buffer(), missingseverity);
                        return false;
                    }
                    else
                    {
                        // Check if we are to bind a default value...
                        if (!isarray && binding.defval)
                        {
                            if (atype == BindingAttribType::INT)
                            {
                                // Single integer
                                param_int = binding.intval;
                                CE_Snippet::bindKernelArgRaw(&param_int, 1, 
                                        kernel, argidx, binding.name, "int", p, error);
                            }
                            else if (tuplesize == 3)
                            {
                                // Float Vector 3
                                param_float3  = binding.v3val;
                                param_fpreal_array[0] = param_float3(0);
                                param_fpreal_array[1] = param_float3(1);
                                param_fpreal_array[2] = param_float3(2);
                                param_fpreal_array[3] = 0;

                                CE_Snippet::bindKernelArgRaw(param_fpreal_array, 4,
                                        kernel, argidx, binding.name, "float3", p, error);
                            }
                            else if (tuplesize == 4)
                            {
                                // Float Vector 4
                                param_float4  = binding.v4val;
                                param_fpreal_array[0] = param_float4(0);
                                param_fpreal_array[1] = param_float4(1);
                                param_fpreal_array[2] = param_float4(2);
                                param_fpreal_array[3] = param_float4(3);
                                CE_Snippet::bindKernelArgRaw(param_fpreal_array, 4,
                                        kernel, argidx, binding.name, "float", p, error);
                            }
                            else
                            {
                                // All other bind a single float default
                                param_float   = binding.fval;
                                CE_Snippet::bindKernelArgRaw(&param_float, 1,
                                        kernel, argidx, binding.name, "float", p, error);
                            }
                        }

                        return true;
                    }
                }

                break;
            }

            case BindingType::VOLUME:
            {
                bool optional = binding.optional;

                // Ignore unbound optional volumes
                if (!op(binding, p, kernel, argidx, error, PREC))
                {
                    if (optional)
                    {
                        // Check if we are to bind a default value...
                        if (binding.defval)
                        {
                            param_float   = binding.fval;
                            CE_Snippet::bindKernelArgRaw(&param_float, 1,
                                    kernel, argidx, binding.name, "float", p, error);
                        }
                        return true;
                    }
                    else
                    {
                        UT_WorkBuffer msg;
                        msg.sprintf("Invalid volume '%s'", (const char *) binding.volume);
                        if (missingseverity != UT_ERROR_NONE)
                            error->addGeneric("Common", UT_ERROR_JUST_STRING, msg.buffer(), missingseverity);
                        return false;
                    }
                }

                break;
            }

            case BindingType::VDB:
            {
                bool optional = binding.optional;

                // Ignore unbound optional volumes
                if (!op(binding, p, kernel, argidx, error, PREC))
                {
                    if (!optional)
                    {
                        UT_WorkBuffer msg;
                        msg.sprintf("Invalid vdb '%s'", (const char *) binding.volume);
                        if (missingseverity != UT_ERROR_NONE)
                            error->addGeneric("Common", UT_ERROR_JUST_STRING, msg.buffer(), missingseverity);
                        return false;
                    }
                    else
                    {
                        // Check if we are to bind a default value...
                        if (binding.defval)
                        {
                            param_float   = binding.fval;
                            CE_Snippet::bindKernelArgRaw(&param_float, 1,
                                    kernel, argidx, binding.name, "float", p, error);
                        }
                        return true;
                    }
                }
                break;
            }

            case BindingType::OPTION:
            {
                bool optional = binding.optional;
                bool defval = binding.defval;
                bool flttype = (binding.optiontype == BindingOptionType::FLOAT);
                int tuplesize = binding.optionsize;

                // Ignore unbound optional volumes
                if (!op(binding, p, kernel, argidx, error, PREC))
                {
                    if (!optional)
                    {
                        UT_WorkBuffer msg;
                        msg.sprintf("Invalid option '%s'", (const char *) binding.optionname);
                        if (missingseverity != UT_ERROR_NONE)
                            error->addGeneric("Common", UT_ERROR_JUST_STRING, msg.buffer(), missingseverity);
                        return false;
                    }
                    else
                    {
                        // Check if we are to bind a default value...
                        if (defval)
                        {
                            if (!flttype)
                            {
                                // Integers are single value.
                                param_int = binding.intval;
                                CE_Snippet::bindKernelArgRaw(&param_int, 1,
                                        kernel, argidx, binding.name, "int", p, error);
                            }
                            else if (tuplesize == 3)
                            {
                                // Float Vector 3
                                param_float3  = binding.v3val;
                                param_fpreal_array[0] = param_float3(0);
                                param_fpreal_array[1] = param_float3(1);
                                param_fpreal_array[2] = param_float3(2);
                                param_fpreal_array[3] = 0;

                                CE_Snippet::bindKernelArgRaw(param_fpreal_array, 4,
                                        kernel, argidx, binding.name, "float3", p, error);
                            }
                            else if (tuplesize == 4)
                            {
                                // Float Vector 4
                                param_float4  = binding.v4val;
                                param_fpreal_array[0] = param_float4(0);
                                param_fpreal_array[1] = param_float4(1);
                                param_fpreal_array[2] = param_float4(2);
                                param_fpreal_array[3] = param_float4(3);
                                CE_Snippet::bindKernelArgRaw(param_fpreal_array, 4,
                                        kernel, argidx, binding.name, "float", p, error);
                            }
                            else
                            {
                                // All other bind a single float default
                                param_float   = binding.fval;
                                CE_Snippet::bindKernelArgRaw(&param_float, 1,
                                        kernel, argidx, binding.name, "float", p, error);
                            }
                        }
                        return true;
                    }
                }
                break;
            }

            case BindingType::LAYER:
            {
                bool optional = binding.optional;
                bool defval = binding.defval;

                // Ignore unbound optional volumes
                if (!op(binding, p, kernel, argidx, error, PREC))
                {
                    if (!optional)
                    {
                        UT_WorkBuffer msg;
                        msg.sprintf("Invalid image '%s'", (const char *) binding.name);
                        if (missingseverity != UT_ERROR_NONE)
                            error->addGeneric("Common", UT_ERROR_JUST_STRING, msg.buffer(), missingseverity);
                        return false;
                    }
                    else
                    {
                        // Check if we are to bind a default value...
                        // Currently always vec4.
                        if (defval)
                        {
                            // Bind a single float4 default
                            param_float4  = binding.v4val;
                            param_fpreal_array[0] = binding.v4val.x();
                            param_fpreal_array[1] = binding.v4val.y();
                            param_fpreal_array[2] = binding.v4val.z();
                            param_fpreal_array[3] = binding.v4val.w();
                            CE_Snippet::bindKernelArgRaw(param_fpreal_array, 4,
                                    kernel, argidx, binding.name, "float4", p, error);
                        }
                        return true;
                    }
                }
                break;
            }
            default:
                break;
        }

        return ok;
    }

}  /// namespace

#endif