random_quda.h

Go to the documentation of this file.

#pragma once
 
#include <lattice_field.h>
 
#ifdef __CUDACC_RTC__
#define RNG int
#else
#include <curand_kernel.h>
 
namespace quda {
 
#if defined(XORWOW)
typedef struct curandStateXORWOW cuRNGState;
#elif defined(MRG32k3a)
typedef struct curandStateMRG32k3a cuRNGState;
#else
typedef struct curandStateMRG32k3a cuRNGState;
#endif
 
class RNG {
 
  private:
  cuRNGState *state;        
  cuRNGState *backup_state; 
  unsigned long long seed;  
  int size;                 
  int size_cb;        
  int X[4];           
  void AllocateRNG(); 
  public:
  RNG(const LatticeField &meta, unsigned long long seedin);
 
  RNG(const LatticeFieldParam &param, unsigned long long seedin);
 
  void Release();
 
  void Init();
 
  unsigned long long Seed() { return seed; };
 
  __host__ __device__ __inline__ cuRNGState *State() { return state; };
 
  void restore();
 
  void backup();
};
 
 
template<class Real>
inline  __device__ Real Random(cuRNGState &state, Real a, Real b){
    Real res;
    return res;
}
 
template<>
inline  __device__ float Random<float>(cuRNGState &state, float a, float b){
    return a + (b - a) * curand_uniform(&state);
}
 
template<>
inline  __device__ double Random<double>(cuRNGState &state, double a, double b){
    return a + (b - a) * curand_uniform_double(&state);
}
 
template<class Real>
inline  __device__ Real Random(cuRNGState &state){
    Real res;
    return res;
}
 
template<>
inline  __device__ float Random<float>(cuRNGState &state){
    return curand_uniform(&state);
}
 
template<>
inline  __device__ double Random<double>(cuRNGState &state){
    return curand_uniform_double(&state);
}
 
 
template<class Real>
struct uniform { };
template<>
struct uniform<float> {
    __device__
        static inline float rand(cuRNGState &state) {
        return curand_uniform(&state);
    }
};
template<>
struct uniform<double> {
    __device__
        static inline double rand(cuRNGState &state) {
        return curand_uniform_double(&state);
    }
};
 
 
 
template<class Real>
struct normal { };
template<>
struct normal<float> {
    __device__
        static inline float rand(cuRNGState &state) {
        return curand_normal(&state);
    }
};
template<>
struct normal<double> {
    __device__
        static inline double rand(cuRNGState &state) {
        return curand_normal_double(&state);
    }
};
 
 
}
 
#endif