ShEval.hpp

// Sh: A GPU metaprogramming language.
//
// Copyright 2003-2005 Serious Hack Inc.
// 
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 
// MA  02110-1301, USA
#ifndef SHEVAL_HPP 
#define SHEVAL_HPP

#include <vector>
#include <map>
#include "ShHashMap.hpp"
#include "ShInfo.hpp"
#include "ShStatement.hpp"
#include "ShVariant.hpp"
#include "ShOperation.hpp"
#include "ShRefCount.hpp"
#include "ShHalf.hpp"

namespace SH {

// forward declarations
//class ShVariant;
class ShEvalOp;
//typedef ShPointer<ShVariant> ShVariant*;
//typedef ShPointer<const ShVariant> const ShVariant*;

struct 
SH_DLLEXPORT
ShEvalOpInfo: public ShInfo {
  ShOperation m_op;

  const ShEvalOp* m_evalOp;

  // type indices of the destination and sources
  // These are set to a valid value type except when the src/dest is not
  // used for m_op 
  ShValueType m_dest;
  ShValueType m_src[3]; 

  ShEvalOpInfo(ShOperation op, const ShEvalOp* evalOp, ShValueType dest, 
      ShValueType src0, ShValueType src1, ShValueType src2);

  ShInfo* clone() const;

  std::string encode() const;
};

class 
SH_DLLEXPORT
ShEval {
  public:
    void operator()(ShOperation op, ShVariant* dest,
        const ShVariant* a, const ShVariant* b, const ShVariant* c) const;

    void operator()(ShOperation op, ShVariantPtr dest,
        ShVariantCPtr a, ShVariantCPtr b, ShVariantCPtr c) const;
    // @}

    void addOp(ShOperation op, const ShEvalOp* evalOp, ShValueType dest, 
        ShValueType src0, ShValueType src1 = SH_VALUETYPE_END, 
        ShValueType src2 = SH_VALUETYPE_END); 

    const ShEvalOpInfo* getEvalOpInfo(ShOperation op, ShValueType dest,
        ShValueType src0, ShValueType src1 = SH_VALUETYPE_END, 
        ShValueType src2 = SH_VALUETYPE_END) const;
    const ShEvalOpInfo* getEvalOpInfo(const ShStatement &stmt) const;

    std::string availableOps() const;

    static ShEval* instance();

  private:
    ShEval();


    typedef std::list<ShEvalOpInfo> OpInfoList;
    typedef OpInfoList OpInfoMap[SH_OPERATION_END];
    OpInfoMap m_evalOpMap; 

    typedef ShPairPairHashMap<ShOperation, ShValueType, ShValueType, ShValueType, const ShEvalOpInfo*> EvalOpCache;
    mutable EvalOpCache  m_evalOpCache;

    static ShEval* m_instance;
};

class 
SH_DLLEXPORT
ShEvalOp {
  public:
    virtual ~ShEvalOp();

    // Wraps an operation where at least dest and a are non-null.
    virtual void operator()(ShVariant* dest, const ShVariant* a, 
        const ShVariant* b, const ShVariant* c) const = 0;
};

// The strategy for defining ops is to use separate classes to hold
// and register operations for different categories of types.
//
// Each of these "concrete" evaluation evalOps must implement
// 1) the virtual void ShEvalOp::operator()(...)
//    This is used to evaluate ShVariables
//
// 2) Functions 
//    template<ShOperation S>
//    static void unaryOp(ShDataVariant<T1> &dest, const ShDataVariant<T2> &src);
//
//    and similarly for binary, ternary ops 
//    (for most ops, only T1 = T2 is supported directly,
//    but for range arithmetic ops, some args may be in a range arithmetic
//    type and other args might not)
//
//    These can be specialized to implement specific ops,
//    and thus used directly for computation on data from
//    ShGenerics without going through ANY layers of virtual 
//    function calls.

template<ShOperation S, typename T>
struct ShRegularOp: public ShEvalOp {
  void operator()(ShVariant* dest, const ShVariant* a, 
      const ShVariant* b, const ShVariant* c) const; 
};

// If functions could be partially specialized, then wouldn't need
// to wrap this in a class.

// TODO might want to break this down into a few more subclasses to handle
// 1) special float/double cmath functions (for C built in types)
// 2) other special functions (sgn, rcp, rsq, etc.) that C types don't have
// OR, use helper functions 
template<ShOperation S, typename T>
struct ShConcreteRegularOp {
  typedef ShDataVariant<T, SH_HOST> Variant;
  typedef Variant* DataPtr; 
  typedef const Variant* DataCPtr; 

  static void doop(DataPtr dest, DataCPtr a, DataCPtr b = 0, DataCPtr c = 0);
};

// has little code snippets for functions like sgn, rcp, rsq, etc.
// that are not built-in cmath functions.
//
//TODO - not all the functions make sense on integer types...may
//want to not declare the ones that don't make sense...
template<ShOperation S, typename T>
struct ShConcreteCTypeOp {
  typedef ShDataVariant<T, SH_HOST> Variant;
  typedef Variant* DataPtr; 
  typedef const Variant* DataCPtr; 

  static void doop(DataPtr dest, DataCPtr a, DataCPtr b = 0, DataCPtr c = 0);
};

template<ShOperation S, typename T>
struct ShRegularOpChooser {
  typedef ShConcreteRegularOp<S, T> Op;
};

#define SHOPC_CTYPE_OP(T)\
template<ShOperation S>\
struct ShRegularOpChooser<S, T> {\
  typedef ShConcreteCTypeOp<S, T> Op;\
};

SHOPC_CTYPE_OP(double);
SHOPC_CTYPE_OP(float);
SHOPC_CTYPE_OP(ShHalf);
SHOPC_CTYPE_OP(int);

// initializes the regular Ops for a floating point type T
// with ShOpEvalOp<OP, T> objects
template<typename T>
void _shInitFloatOps();

// initializes the regular Ops for an integer type T
// (a subset of the floating point ones)
template<typename T>
void _shInitIntOps();

}

#include "ShEvalImpl.hpp"
#include "ShConcreteRegularOpImpl.hpp"
#include "ShConcreteCTypeOpImpl.hpp"

#endif

---