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