VM/VM_SIMD.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
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        VM_SIMD.C ( VM Library, C++)
 *
 * COMMENTS:
 */

#ifndef __VM_SIMD__
#define __VM_SIMD__

//#define FORCE_NON_SIMD

// Some older versions of glibc don't correctly align the stack for extra
// threads (this problem should have been fixed in 2.3.4 - see
// http://sources.redhat.com/bugzilla/show_bug.cgi?id=723).  Instead of
// checking the glibc version, check the compiler version and assume newer
// compilers are used with newer glibc.

#if defined __GNUC__
#define VM_CHECK_GCC(MAJOR, MINOR) \
    (__GNUC__ > MAJOR || (__GNUC__ == MAJOR && __GNUC_MINOR__ >= MINOR))
#else
#define VM_CHECK_GCC(MAJOR, MINOR) 0
#endif

#if defined(FORCE_NON_SIMD)
    #include "VM_BasicFunc.h"
#else
    #if defined(CELLRSX) || defined(PPC)
        #include "VM_AltivecFunc.h"
    #elif defined(LINUX) && VM_CHECK_GCC(3, 4) && defined(__SSE__)
        #include "VM_SSEFunc.h"
    #elif defined(WIN32)
        #include "VM_SSEFunc.h"
    #elif defined(MBSD_INTEL)
        #include "VM_SSEFunc.h"
    #else
        #include "VM_BasicFunc.h"
    #endif
#endif

//#if defined(CPU_HAS_SIMD_INSTR)

class v4uf;

class v4uu {
public:
             v4uu() {}
             v4uu(const v4si &v) : vector(v)              {}
             v4uu(const v4uu &v) : vector(v.vector)       {} 
    explicit v4uu(int32 v) { VM_SPLATS(vector, v); }
    explicit v4uu(const int32 v[4])
                { VM_SPLATS(vector, v[0], v[1], v[2], v[3]); }
             v4uu(int32 a, int32 b, int32 c, int32 d)
                { VM_SPLATS(vector, a, b, c, d); }

    // Assignment
    inline v4uu operator=(int32 v)
                { vector = v4uu(v).vector; return *this; }
    inline v4uu operator=(v4si v)
                { vector = v; return *this; }
    inline v4uu operator=(const v4uu &v)
                { vector = v.vector; return *this; }
    
    inline void condAssign(const v4uu &val, const v4uu &c)
                { *this = (c & val) | (!c & *this); }

    // Comparison
    inline v4uu operator == (const v4uu &v) const
                { return v4uu(VM_ICMPEQ(vector, v.vector)); }
    inline v4uu operator != (const v4uu &v) const
                { return ~(*this == v); }
    inline v4uu operator >  (const v4uu &v) const
                { return v4uu(VM_ICMPGT(vector, v.vector)); }
    inline v4uu operator <  (const v4uu &v) const
                { return v4uu(VM_ICMPLT(vector, v.vector)); }
    inline v4uu operator >= (const v4uu &v) const
                { return ~(*this < v); }
    inline v4uu operator <= (const v4uu &v) const
                { return ~(*this > v); }

    inline v4uu operator == (int32 v) const { return *this == v4uu(v); }
    inline v4uu operator != (int32 v) const { return *this != v4uu(v); }
    inline v4uu operator >  (int32 v) const { return *this > v4uu(v); }
    inline v4uu operator <  (int32 v) const { return *this < v4uu(v); }
    inline v4uu operator >= (int32 v) const { return *this >= v4uu(v); }
    inline v4uu operator <= (int32 v) const { return *this <= v4uu(v); }
    
    // Basic math
    inline v4uu operator+(const v4uu &r) const
                 { return v4uu(VM_IADD(vector, r.vector)); }
    inline v4uu operator-(const v4uu &r) const
                 { return v4uu(VM_ISUB(vector, r.vector)); }
    inline v4uu operator+=(const v4uu &r) { return (*this = *this + r); }
    inline v4uu operator-=(const v4uu &r) { return (*this = *this - r); }
    inline v4uu operator+(int32 r) const { return *this + v4uu(r); }
    inline v4uu operator-(int32 r) const { return *this - v4uu(r); }
    inline v4uu operator+=(int32 r) { return (*this = *this + r); }
    inline v4uu operator-=(int32 r) { return (*this = *this - r); }

    // logical/bitwise
    
    inline v4uu operator||(const v4uu &r) const
                { return v4uu(VM_OR(vector, r.vector)); }
    inline v4uu operator&&(const v4uu &r) const
                { return v4uu(VM_AND(vector, r.vector)); }
    inline v4uu operator^(const v4uu &r) const
                { return v4uu(VM_XOR(vector, r.vector)); }
    inline v4uu operator!() const
                { return *this == v4uu(0); }
    
    inline v4uu  operator|(const v4uu &r) const { return *this || r; }
    inline v4uu  operator&(const v4uu &r) const { return *this && r; }
    inline v4uu  operator~() const
                { return *this ^ v4uu(0xFFFFFFFF); }

    // component
    inline int32 operator[](int idx) const { return comp[idx]; }
    inline void  setComp(int idx, int32 v) { comp[idx] = v; }

    v4uf         toFloat() const;

public:
    union {
        v4si            vector;
        int32           comp[4];
    };
};

class v4uf {
public:
             v4uf() {}
             v4uf(const v4sf &v) : vector(v)              {} 
             v4uf(const v4uf &v) : vector(v.vector)       {} 
    explicit v4uf(float v) { VM_SPLATS(vector, v); }
    explicit v4uf(const float v[4])
                { VM_SPLATS(vector, v[0], v[1], v[2], v[3]); }
             v4uf(float a, float b, float c, float d)
                { VM_SPLATS(vector, a, b, c, d); }

    // Assignment
    inline v4uf operator=(float v)
                { vector = v4uf(v).vector; return *this; }
    inline v4uf operator=(v4sf v)
                { vector = v; return *this; }
    inline v4uf operator=(const v4uf &v)
                { vector = v.vector; return *this; }
    
    inline void condAssign(const v4uf &val, const v4uu &c)
                { *this = (val & c) | (*this & ~c); }

    // Comparison
    inline v4uu operator == (const v4uf &v) const
                { return v4uu(VM_CMPEQ(vector, v.vector)); }
    inline v4uu operator != (const v4uf &v) const
                { return v4uu(VM_CMPNE(vector, v.vector)); }
    inline v4uu operator >  (const v4uf &v) const
                { return v4uu(VM_CMPGT(vector, v.vector)); }
    inline v4uu operator <  (const v4uf &v) const
                { return v4uu(VM_CMPLT(vector, v.vector)); }
    inline v4uu operator >= (const v4uf &v) const
                { return v4uu(VM_CMPGE(vector, v.vector)); }
    inline v4uu operator <= (const v4uf &v) const
                { return v4uu(VM_CMPLE(vector, v.vector)); }

    inline v4uu operator == (float v) const { return *this == v4uf(v); }
    inline v4uu operator != (float v) const { return *this != v4uf(v); }
    inline v4uu operator >  (float v) const { return *this > v4uf(v); }
    inline v4uu operator <  (float v) const { return *this < v4uf(v); }
    inline v4uu operator >= (float v) const { return *this >= v4uf(v); }
    inline v4uu operator <= (float v) const { return *this <= v4uf(v); }
    

    // Basic math
    inline v4uf operator+(const v4uf &r) const
                 { return v4uf(VM_ADD(vector, r.vector)); }
    inline v4uf operator-(const v4uf &r) const
                 { return v4uf(VM_SUB(vector, r.vector)); }
    inline v4uf operator-() const
                 { return v4uf(VM_NEG(vector)); }
    v4uf         operator*(const v4uf &r) const
                 { return v4uf(VM_MUL(vector, r.vector)); }
    v4uf         operator/(const v4uf &r) const
                 { return v4uf(VM_DIV(vector, r.vector)); }

    inline v4uf operator+=(const v4uf &r) { return (*this = *this + r); }
    inline v4uf operator-=(const v4uf &r) { return (*this = *this - r); }
    inline v4uf operator*=(const v4uf &r) { return (*this = *this * r); }
    inline v4uf operator/=(const v4uf &r) { return (*this = *this / r); }

    inline v4uf operator+(float r) const { return *this + v4uf(r); }
    inline v4uf operator-(float r) const { return *this - v4uf(r); }
    inline v4uf operator*(float r) const { return *this * v4uf(r); }
    inline v4uf operator/(float r) const { return *this / v4uf(r); }
    inline v4uf operator+=(float r) { return (*this = *this + r); }
    inline v4uf operator-=(float r) { return (*this = *this - r); }
    inline v4uf operator*=(float r) { return (*this = *this * r); }
    inline v4uf operator/=(float r) { return (*this = *this / r); }
    
    // logical/bitwise
    
    inline v4uf operator||(const v4uu &r) const
                { return v4uf(V4SF(VM_OR(V4SI(vector), r.vector))); }
    inline v4uf operator&&(const v4uu &r) const
                { return v4uf(V4SF(VM_AND(V4SI(vector), r.vector))); }
    inline v4uf operator^(const v4uu &r) const
                { return v4uf(V4SF(VM_XOR(V4SI(vector), r.vector))); }
    inline v4uf operator!() const
                { return v4uf(V4SF((*this == v4uf(0.0F)).vector)); }
    
    inline v4uf operator||(const v4uf &r) const
                { return v4uf(V4SF(VM_OR(V4SI(vector), V4SI(r.vector)))); }
    inline v4uf operator&&(const v4uf &r) const
                { return v4uf(V4SF(VM_AND(V4SI(vector), V4SI(r.vector)))); }
    inline v4uf operator^(const v4uf &r) const
                { return v4uf(V4SF(VM_XOR(V4SI(vector), V4SI(r.vector)))); }
    
    inline v4uf  operator|(const v4uu &r) const { return *this || r; }
    inline v4uf  operator&(const v4uu &r) const { return *this && r; }
    inline v4uf  operator~() const
                { return *this ^ v4uu(0xFFFFFFFF); }

    inline v4uf  operator|(const v4uf &r) const { return *this || r; }
    inline v4uf  operator&(const v4uf &r) const { return *this && r; }

    // component
    inline float operator[](int idx) const { return comp[idx]; }
    inline void  setComp(int idx, float v) { comp[idx] = v; }

    // more math
    v4uf         abs() const { return v4uf(VM_ABS(vector)); }
    v4uf         clamp(const v4uf &low, const v4uf &high) const
                 { return v4uf(
                         VM_MIN(VM_MAX(vector, low.vector), high.vector)); }
    v4uf         clamp(float low, float high) const
                 { return v4uf(VM_MIN(VM_MAX(vector,
                                 v4uf(low).vector), v4uf(high).vector)); }
    v4uf         recip() const { return v4uf(VM_INVERT(vector)); }
    
    /// This is a lie, it is a signed int.
    /// these are only safe on SSE2 where we don't need to reset
    /// the rounding mode, otherwise it is caller's responsibility
    /// to do a VM_P_INT and VM_E_INT.
    v4uu         toUnsignedInt() const { return VM_INT(vector); }
    v4uu         toSignedInt() const { return VM_INT(vector); }

    v4uu         floor() const
                 {
                     v4uu               result;
                     VM_P_FLOOR();
                     result = VM_FLOOR(vector);
                     VM_E_FLOOR();
                     return result;
                 }

    /// Returns the integer part of this float, this becomes the
    /// 0..1 fractional component.
    v4uu         splitFloat()
                 {
                     v4uu       base;
                     base = toSignedInt();
                     *this -= base.toFloat();
                     return base;
                 }

    template <int A, int B, int C, int D>
    v4uf        swizzle() const
                { 
                    return VM_SHUFFLE<A,B,C,D>(vector);
                }

public:
    union {
        v4sf            vector;
        fpreal32        comp[4];
    };
};

inline v4uf
v4uu::toFloat() const
{
    return v4uf(VM_IFLOAT(vector));
}

//
// Custom vector operations
//

static inline v4uf
sqrt(const v4uf &a)
{
    return v4uf(VM_SQRT(a.vector));
}

static inline v4uf
fabs(const v4uf &a)
{
    return a.abs();
}

// Use this operation to mask disabled values to 0
// rval = !a ? b : 0;

static inline v4uf
andn(const v4uu &a, const v4uf &b)
{
    return v4uf(V4SF(VM_ANDNOT(a.vector, V4SI(b.vector))));
}

static inline v4uu
andn(const v4uu &a, const v4uu &b)
{
    return v4uu(VM_ANDNOT(a.vector, b.vector));
}

// rval = a ? b : c;
static inline v4uf
ternary(const v4uu &a, const v4uf &b, const v4uf &c)
{
    return (b & a) | andn(a, c);
}

static inline v4uu
ternary(const v4uu &a, const v4uu &b, const v4uu &c)
{
    return (b & a) | andn(a, c);
}

// rval = !(a && b)
static inline v4uu
nand(const v4uu &a, const v4uu &b)
{
    return !v4uu(VM_AND(a.vector, b.vector));
}

static inline v4uf
vmin(const v4uf &a, const v4uf &b)
{
    return v4uf(VM_MIN(a.vector, b.vector));
}

static inline v4uf
vmax(const v4uf &a, const v4uf &b)
{
    return v4uf(VM_MAX(a.vector, b.vector));
}

static inline v4uf
clamp(const v4uf &a, const v4uf &b, const v4uf &c)
{
    return vmax(vmin(a, c), b);
}

static inline v4uf
clamp(const v4uf &a, float b, float c)
{
    return vmax(vmin(a, v4uf(c)), v4uf(b));
}

static inline bool
allbits(const v4uu &a)
{
    return vm_allbits(a.vector);
}

static inline bool
anybits(const v4uu &a)
{
    return !allbits(~a);
}

static inline v4uf
madd(const v4uf &v, const v4uf &f, const v4uf &a)
{
    return v4uf(VM_MADD(v.vector, f.vector, a.vector));
}

static inline v4uf
madd(const v4uf &v, float f, float a)
{
    return v4uf(VM_MADD(v.vector, v4uf(f).vector, v4uf(a).vector));
}

static inline v4uf
msub(const v4uf &v, const v4uf &f, const v4uf &s)
{
    return madd(v, f, -s);
}

static inline v4uf
msub(const v4uf &v, float f, float s)
{
    return madd(v, f, -s);
}

static inline v4uf
lerp(const v4uf &a, const v4uf &b, const v4uf &w)
{
    v4uf w1 = v4uf(1.0F) - w;
    return madd(a, w1, b*w);
}

static inline v4uf
luminance(const v4uf &r, const v4uf &g, const v4uf &b,
          float rw, float gw, float bw)
{
    return v4uf(madd(r, v4uf(rw), madd(g, v4uf(gw), b * bw)));
}

static inline float
dot3(const v4uf &a, const v4uf &b)
{
    v4uf res = a*b;
    return res[0] + res[1] + res[2];
}

static inline float
dot4(const v4uf &a, const v4uf &b)
{
    v4uf res = a*b;
    return res[0] + res[1] + res[2] + res[3];
}

static inline float
length(const v4uf &a)
{
    return sqrt(dot3(a, a));
}

static inline v4uf
normalize(const v4uf &a)
{
    return a / length(a);
}

static inline v4uf
cross(const v4uf &a, const v4uf &b)
{
    return v4uf(a[1]*b[2] - a[2]*b[1],
                a[2]*b[0] - a[0]*b[2],
                a[0]*b[1] - a[1]*b[0], 0);
}

// Currently there is no specific support for signed integers
typedef v4uu v4ui;

// Assuming that ptr is an array of elements of type STYPE, this operation
// will return the index of the first element that is aligned to (1<<ASIZE)
// bytes.
#define VM_ALIGN(ptr, ASIZE, STYPE)     \
                ((((1<<ASIZE)-(long)ptr)&((1<<ASIZE)-1))/sizeof(STYPE))

//#endif // defined(CPU_HAS_SIMD_INSTR)

#endif

---