tensor_base.h

Go to the documentation of this file.

#ifndef MSHADOW_TENSOR_BASE_H
#define MSHADOW_TENSOR_BASE_H

#include <cmath>
#include <cstdio>
#include <cfloat>
#include <climits>
#include <algorithm>
// macro defintiions

#ifndef MSHADOW_STAND_ALONE
    #define MSHADOW_STAND_ALONE 0
#endif

#ifndef MSHADOW_ALLOC_PAD
    #define MSHADOW_ALLOC_PAD true
#endif

#ifndef MSHADOW_MIN_PAD_RATIO
    #define MSHADOW_MIN_PAD_RATIO 2
#endif

#if MSHADOW_STAND_ALONE
   #define MSHADOW_USE_CBLAS 0
   #define MSHADOW_USE_MKL   0
   #define MSHADOW_USE_CUDA  0
#endif

#ifndef MSHADOW_USE_CBLAS
   #define MSHADOW_USE_CBLAS 0
#endif

#ifndef MSHADOW_USE_MKL
   #define MSHADOW_USE_MKL   1
#endif

#ifndef MSHADOW_USE_CUDA
  #define MSHADOW_USE_CUDA   1
#endif

#ifndef MSHADOW_SINGLE_PRECISION
  #define MSHADOW_SINGLE_PRECISION 1
#endif

#ifndef MSHADOW_USE_SSE
  #define MSHADOW_USE_SSE 1
#endif

#ifndef MSHADOW_USE_NVML
  #define MSHADOW_USE_NVML 0
#endif
// SSE is conflict with cudacc
#ifdef __CUDACC__
  #undef MSHADOW_USE_SSE
  #define MSHADOW_USE_SSE 0
#endif

#if MSHADOW_USE_CBLAS
extern "C"{
    #include <cblas.h>
}
#elif MSHADOW_USE_MKL
  #include <mkl.h>
  #include <mkl_cblas.h>
  #include <mkl_vsl.h>
  #include <mkl_vsl_functions.h>
#endif

#if MSHADOW_USE_CUDA
  #include <cublas.h>
  #include <curand.h>
#endif

#if MSHADOW_USE_NVML
  #include <nvml.h>
#endif
// --------------------------------
// MSHADOW_XINLINE is used for inlining template code for both CUDA and CPU code.
#ifdef MSHADOW_XINLINE
  #error "MSHADOW_XINLINE must not be defined"
#endif
#ifdef __CUDACC__
  #define MSHADOW_XINLINE inline __attribute__((always_inline)) __device__ __host__
#else
  #define MSHADOW_XINLINE inline __attribute__((always_inline))
#endif

#define MSHADOW_CINLINE inline __attribute__((always_inline))

#if defined(__GXX_EXPERIMENTAL_CXX0X) || defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L
  #define MSHADOW_CONSTEXPR constexpr
#else
  #define MSHADOW_CONSTEXPR const
#endif

namespace mshadow {
    const unsigned kRandBufferSize = 1000000;
    const float kPi = 3.1415926f;

#if MSHADOW_SINGLE_PRECISION

    typedef float real_t;
#else
    typedef double real_t;
#endif

    typedef unsigned index_t;
}; // namespace mshadow

namespace mshadow {
    namespace op {
        // binary operator
        struct mul{
            MSHADOW_XINLINE static real_t Map(real_t a, real_t b) {
                return a * b;
            }
        };
        struct plus {
            MSHADOW_XINLINE static real_t Map(real_t a, real_t b) {
                return a + b;
            }
        };
        struct minus {
            MSHADOW_XINLINE static real_t Map(real_t a, real_t b) {
                return a - b;
            }
        };
        struct div {
            MSHADOW_XINLINE static real_t Map(real_t a, real_t b) {
                return a / b;
            }
        };
        struct right {
            MSHADOW_XINLINE static real_t Map(real_t a, real_t b) {
                return b;
            }
        };
    }; // namespace op

    namespace sv {
        struct saveto {
            MSHADOW_XINLINE static void Save(real_t& a, real_t b) {
                a  = b;
            }
            MSHADOW_CONSTEXPR static real_t kAlphaBLAS = 1.0f;
            MSHADOW_CONSTEXPR static real_t kBetaBLAS  = 0.0f;
            typedef op::right OPType;
        };
        struct plusto {
            MSHADOW_XINLINE static void Save(real_t& a, real_t b) {
                a += b;
            }
            MSHADOW_CONSTEXPR static real_t kAlphaBLAS = 1.0f;
            MSHADOW_CONSTEXPR static real_t kBetaBLAS  = 1.0f;
            typedef op::plus OPType;
        };
        struct minusto {
            MSHADOW_XINLINE static void Save(real_t& a, real_t b) {
                a -= b;
            }
            MSHADOW_CONSTEXPR static real_t kAlphaBLAS = -1.0f;
            MSHADOW_CONSTEXPR static real_t kBetaBLAS  = 1.0f;
            typedef op::minus OPType;
        };
        struct multo {
            MSHADOW_XINLINE static void Save(real_t& a, real_t b) {
                a *= b;
            }
            typedef op::mul OPType;
        };
        struct divto {
            MSHADOW_XINLINE static void Save(real_t& a, real_t b) {
                a /= b;
            }
            typedef op::div OPType;
        };
    }; // namespace sv


    namespace op {
        // unary operator/ function: example
        // these operators can be defined by user, in the same style as binary and unary operator
        // to use, simply write F<op::identity>( src )
        struct identity{
            MSHADOW_XINLINE static real_t Map(real_t a) {
                return a;
            }
        };
    }; // namespace op

    namespace red {
        struct sum {
            MSHADOW_XINLINE static void Reduce( volatile real_t& dst,  volatile real_t src ) {
                dst += src;
            }
            MSHADOW_XINLINE static real_t PartialGrad( real_t redres, real_t redsrc ) {
                return 1.0f;
            }
            MSHADOW_CONSTEXPR static real_t kInitV = 0.0f;
        };
        struct maximum {
            MSHADOW_XINLINE static void Reduce( volatile real_t& dst,  volatile real_t src ) {
                using namespace std;
                dst = max( dst, src );
            }
            MSHADOW_XINLINE static real_t PartialGrad( real_t redres, real_t redsrc ) {
                return redres == redsrc ? 1.0f: 0.0f;
            }
#if MSHADOW_SINGLE_PRECISION
            MSHADOW_CONSTEXPR static real_t kInitV = -FLT_MAX;
#else
            MSHADOW_CONSTEXPR static real_t kInitV = -DBL_MAX;
#endif
        };
    };

    namespace utils{
        inline void Error( const char *msg ){
            fprintf( stderr, "Error:%s\n",msg );
            exit( -1 );
        }
        inline void Assert( bool exp ){
            if( !exp ) Error( "AssertError" );
        }
        inline void Assert( bool exp, const char *msg ){
            if( !exp ) Error( msg );
        }
        inline void Warning( const char *msg ){
            fprintf( stderr, "warning:%s\n",msg );
        }
    }; // namespace utils
}; // namespace mshadow
#endif // TENSOR_BASE_H