CE_Vector.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_VectorT.h ( CE Library, C++)
 *
 * COMMENTS: Compute Engine Vector.
 */

#ifndef __CE_Vector__
#define __CE_Vector__

#include "CE_API.h"
#include "CE_Context.h"

#include <UT/UT_Vector.h>

/// A simple OpenCL-based vector class that at the moment just mimics just
/// enough of UT_Vector to be used in CE_SparseMatrixELLT::solveConjugateGradient.
template <typename T>
class CE_API CE_VectorT
{
public:

    typedef T    value_type;

    CE_VectorT();

    /// Initialize to given length.
    CE_VectorT(exint len, bool use_pool=false, bool read=true, bool write=true);

    /// Initialize to zero in in the cases when we want to 
    /// init / not init the vector based on size    
    CE_VectorT(bool use_pool,
               bool read,
               bool write);

    /// Copy constructor.
    CE_VectorT(const CE_VectorT<T> &v);

    ~CE_VectorT();

    /// Initialize to given length.
    /// NOTE- values are undefined.
    void        init(exint len, bool doalloc=true);

    /// For "compatibility" with UT_Vector.
    /// NOTE: Asserts if nl is not zero!
    void        init(exint nl, exint nh);

    /// Initialize from a UT_Vector.
    void        initFromVector(const UT_VectorT<T> &src, bool block = true);

    /// Initialize from a cl::Buffer, which this vector does *not* own.
    void        initFromBuffer(const cl::Buffer &src, exint size, int tuplesize = 1);

    /// Resize the provided UT_Vector to fit and copy this vector's data there.
    void        matchAndCopyToVector(UT_VectorT<T> &dst, bool block = true) const;
    /// Returns the vector length.
    exint       length() const { return myLen; }
    /// Returns the size of the tuple contained in the vector.
    int         tupleSize() const { return myTupleSize; }
    /// Returns the number of tuples contained in the vector.
    exint       tupleCount() const { return myLen / myTupleSize; }

    /// Returns the underlying OpenCL buffer.
    const cl::Buffer &buffer() const { return myBuffer; }

    /// The following functions all mimic those of the same name in UT_Vector.
    void        multAndSet(const CE_VectorT<T> &a, const CE_VectorT<T> &b);

    void        negPlus(const CE_VectorT<T> &a);

    void        scaleAddVec(T s, const CE_VectorT<T> &a);

    fpreal64    norm(int type) const;

    void        zero() { setValue(0); }

    void        addScaledVec(T s, const CE_VectorT<T> &a);

    /// Operators
    /// NOTE: operator= requires the destination be a matching size.
    CE_VectorT &operator= (const CE_VectorT<T> &v);

    /// Reductions of the vector to a single value.
    fpreal64 sum(int comp = 0) const;
    fpreal64 sumAbs(int comp = 0) const;
    fpreal64 sumSqr(int comp = 0) const;
    fpreal64 min(int comp = 0) const;
    fpreal64 minAbs(int comp = 0) const;
    fpreal64 max(int comp = 0) const;
    fpreal64 maxAbs(int comp = 0) const;
    fpreal64 average(int comp = 0) const { return sum(comp) / tupleCount(); }
    fpreal64 rms(int comp = 0) const { return SYSsqrt(sumSqr(comp) / tupleCount()); }

    /// Returns the dot product with provided vector.
    fpreal64 dot(const CE_VectorT<T> &a) const;

    cl::KernelFunctor bind(cl::Kernel &k) const;
    void setValue(T cval);
    void copyFrom(const CE_VectorT<T> &v);
protected:

    const cl::Buffer &allocBuffer() const;
    void releaseBuffer();
    cl::KernelFunctor bind(const char *kernel_name) const;
    cl::Kernel loadKernel(const char *kernel_name, const char *opt = NULL) const;


    // Reduction helpers
    void getReductionRanges(const cl::Kernel &k,
                            cl::NDRange &global_range, cl::NDRange &local_range,
                            uint &groupsize, uint &ngroups,
                            size_t &accumsize) const;
    fpreal64 reduceGroup(cl::Buffer out, uint groupsize, uint ngroups,
                        size_t accumsize, const char *reduce_flags) const;

    // Main reduction function.
    fpreal64 doReduce(
            const char *reduce_flags,
            const CE_VectorT<T> *a = NULL,
            int tuplesize = 1,
            int comp = 0) const;

    mutable cl::Buffer  myBuffer;
    cl::NDRange         myGlobalRange, myLocalRange;
    exint               myLen;
    int                 myTupleSize;

    bool                myRead, myWrite, myUsePool;
};

template <typename T>
inline fpreal64
dot(const CE_VectorT<T> &a, const CE_VectorT<T> &b)
{
    return a.dot(b);
}


typedef CE_VectorT<fpreal32>    CE_VectorF;
typedef CE_VectorT<fpreal64>    CE_VectorD;

#endif